python9-14

实验09(字典)

一、课内实验题（共5小题，50分）
题型得分 50
【描述】
输入一个1到7的数字，输出对应的星期名的缩写。
1 Mon
2 Tue
3 Wed
4 Thu
5 Fri
6 Sat
7 Sun
【输入】
输入1到7之间数字。
【输出】
输出对应的星期名的缩写。
【输入示例】

1
【输出示例】
Mon

（10分）
我的答案：

dict1={1:'Mon',2:'Tue',3:'Wed',4:'Thu',5:'Fri',6:'Sat',7:'Sun'}
n=int(input())
print(dict1[n])

题目得分 10
【描述】
输入一个简单英文句子，统计并依次输出该句子中元音字母a、e、i、o、u（不区分大小写）出现的次数。
【输入】
一行中输入一个简单英文句子。
【输出】
一行中依次输出a、e、i、o、u在句子中出现的次数，整数以空格间隔。
【输入示例】
If so,you already have a Google Account. You can sign in on the right.
【输出示例】
6 4 4 7 3
【来源】
《Python程序设计基础》第6章编程题3。（10分）
我的答案：

s=input()
s=s.lower()
s1=list(s)
d={}
for i in s1:
    if i in 'aeiou':
        if i in d:
            d[i]+=1
        else:
            d[i]=1
print(d['a'],d['e'],d['i'],d['o'],d['u'])

题目得分 10
【描述】
定义函数：def number_to_words(number)，该函数接受一个整数作为参数；返回一个小写英文字符串，字符串的单词描述了该整数。
英文单词：zero、one、two、three、four、five、six、seven、eight、nine。
例如，如果输入的整数是：-4721，函数返回字符串：“negative four seven two one”。
【输入】
输入一个整数。
【输出】
整数的英文单词描述（单词之间以一个空格间隔）。
【输入示例】

-4721
【输出示例】
negative four seven two one
【来源】
《Python程序设计基础》第6章编程题4。
（10分）
我的答案：

def number_to_words(number):
    n2=str(number)
    list1=list(n2)
    l2=[]
    d={'-':'negative','0':'zero','1':'one','2':'two','3':'three','4':'four','5':'five','6':'six','7':'seven','8':'eight','9':'nine'}
    for i in list1:
        l2.append(d[i])
    return l2
n=int(input())
print(' '.join(number_to_words(n)))

题目得分 10
【描述】
定义函数：def formatted_print(dictionary)，该函数接受一个字典作为参数，字典的键是学生姓名，字典的值是对应学生的平均分数。函数按照如下所指定的格式打印学生姓名及其对应的平均分数。
例如，如果输入的字典是：{‘john’:34.480,‘eva’:88.5, ‘alex’:90.55, ‘tim’: 65.900}，函数打印出如下信息：

alex 90.55
eva 88.50
tim 65.90
john 34.48
姓名输出宽度10且左对齐；平均分数输出宽度6，保留2位小数，且右对齐。
所有这些信息按照学生的平均分数降序排序输出。
输入数据，调用该函数，输出结果。
【输入】
每一行输入姓名、平均分数，其间以逗号分隔。每行数据构成字典的一个键值对。可能会有多行输入。
【输出】
见【输出示例】。
【输入示例】
john,34.480
eva,88.5
alex,90.55
tim,65.900
【输出示例】
alex 90.55
eva 88.50
tim 65.90
john 34.48
（10分）
我的答案：

def formatted_print(d):
    counts=dict(sorted(d.items(),key=lambda d:d[1],reverse=True))
    return counts
lst=[]
for i in iter(input,""):
    m=i.split(',')
    lst.append(tuple(m))
    d=dict(lst)
for key,value in formatted_print(d).items():
    if float(value)==100.00:
        print('%-10s%6.2f' % (key, float(value)))
        break
for key,value in formatted_print(d).items():
    if float(value)!=100.0:
        print('%-10s%6.2f'%(key,float(value)))

题目得分 10
【描述】
给定公司n名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。
【输入】
一行中给出n个整数，即每个员工的工龄，范围在[0, 50]，整数间以空格间隔。
【输出】
按工龄的递增顺序输出每个工龄的员工个数，格式为：工龄:人数。每项占一行。如果人数为0则不输出该项。
【输入示例】

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

line =input().split()
numbers=[int(x) for x in line]
d={}
for number in numbers:
    if number in d:
        d[number]+=1
    else:
        d[number]=1
counts=sorted(list(d.items()))
for i in range(len(counts)):
    print(counts[i][0],":",counts[i][1],sep='')

题目得分 10

实验10(集合)

一、课内实验题（共5小题，50分）
题型得分 50
【描述】
输入若干个整数，输出其中出现了多少个不相同的数。
【输入】
一行中输入若干个整数，整数之间以空格分隔。
【输出】
一个数字，表示多少个不相同的数。
【输入示例】

1 1 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
【输出示例】
19
【来源】
《Python程序设计基础》第6章编程题1。
（10分）
我的答案：

line =input().split()
numbers=[int(x) for x in line]
se=set(numbers)
print(len(se))

题目得分 10
参考答案：

numbers = [int(x) for x in input().split()]
new_numbers = list(set(numbers))
print(len(new_numbers))

【描述】
小慧最近在数学课上学习了集合。小慧的老师给了小慧这样一个集合：
s = { p / q | w ≤ p ≤ x, y ≤ q ≤ z }
根据给定的w、x、y、z，求出集合中一共有多少个元素。
【输入】
4个整数，分别是w（1 ≤ w ≤ x），x（1 ≤ x ≤ 100），y（1 ≤ y ≤ z），z（1 ≤ z ≤ 100），以空格分隔。
【输出】
集合中元素的个数。
【输入示例】

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

w,x,y,z=map(int,input().split())
s=set()
for i in range(w,x+1):
    for j in range(y,z+1):
        s.add(i/j)
print(len(s))

题目得分 10
参考答案：

w, x, y, z = (int(value) for value in input().split())
p = [value for value in range(w, x + 1)]
q = [value for value in range(y, z + 1)]
result = [p[i] / q[j] for i in range(len(p)) for j in range(len(q))]
print(len(set(result)))

【描述】
输入n个整数，对这n个整数去重之后按原顺序输出。
【输入】
一行中输入n个整数。其中1≤n≤100，每个数的范围1≤x≤n。整数之间以空格间隔。
【输出】
去重之后按原顺序输出。
【输入示例】

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

line =input().split()
numbers=[int(x) for x in line]
lst2=[]
[lst2.append(i) for i in numbers if not i in lst2]
for i in range(len(lst2)):
    print(lst2[i],end=" ")

题目得分 10
参考答案：

numbers = [int(x) for x in input().split()]
new_numbers = list(set(numbers))
new_numbers.sort(key = numbers.index)
for x in new_numbers:
    print(x, end=' ')
print()

【描述】
分析活动投票情况。第一小队有五名队员，序号是1、2、3、4、5；第二小队也有五名队员，序号6、7、8、9、10。输入一个得票字符串，求第二小队没有得票的队员序号。
【输入】
在一行中输入得票的队员的序列号，用逗号隔开。
【输出】
在一行中输出第二小队没有得票的队员序号。
【输入示例】

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

line =input().split(',')
numbers=[int(x) for x in line]
se=set(numbers)
for i in range(6,11):
    if i not in se:
        print(i,end=' ')

题目得分 10
参考答案：

set1 = {6, 7, 8, 9, 10}
lst = [int(x) for x in input().split(',')]
set2 = set(lst)
result = list(set1 - set2)
result.sort()
for x in result:
    print(x, end = ' ')

【描述】
给定两组整数，要求找出不是两者共有的元素。
【输入】
分别在两行中给出两组整数，整数间以空格分隔。
【输出】
在一行中按照数字给出的顺序输出不是两者共有的元素，数字间以空格分隔，但行末不得有多余的空格。
题目保证至少存在一个这样的数字。同一数字不重复输出。
【输入示例】
3 -5 2 8 0 3 5 -15 9 100
6 4 8 2 6 -5 9 0 100 8 1
【输出示例】
3 5 -15 6 4 1
（10分）
我的答案：

a1 = list(map(int,input().split()))
b1 = list(map(int,input().split()))
s = []
for i in a1:
    if i not in b1 and i not in s:
        s.append(i)
for i in b1:
    if i not in a1 and i not in s:
        s.append(i)
for i in s:
    print(i,end=' ')

题目得分 10
参考答案：

lst1 = [int(x) for x in input().split()]
lst2 = [int(x) for x in input().split()]
lst3 = lst1 + lst2
set1 = set(lst1)
set2 = set(lst2)
result = list(set1 ^ set2)
result.sort(key = lst3.index)
length = len(result)
for i in range(length - 1):
    print(result[i], end = ' ')
print(result[length - 1])

实验11(对象和类)

一、课内实验题（共5小题，50分）
题型得分 50
【描述】
设计一个Point类，表示直角坐标系中的一个点。Point类包括：

私有数据域x和y，表示坐标。
构造方法，将坐标x和y设置为给定的参数。x和y的默认参数值为0。
访问器方法get_x和get_y，分别用于访问点的x坐标和y坐标。
一个名为distance的成员方法，返回两个点之间的距离。
【输入】
有两行。每一行给出一个坐标点坐标x和y，其间以空格分隔。
【输出】
有三行。前两行输出坐标点坐标。最后一行中输出两个坐标点之间的距离，结果保留2位小数。
【输入示例】

0 0
10 30.5
【输出示例】
(0.0,0.0)
(10.0,30.5)
32.10
【来源】
《Python程序设计基础》第7章编程题1。
【提示】
只需编写Point类，递交时会测试该类。
（10分）
我的答案：

class Point:
    def __init__(self,x=0,y=0):
        self.__x=x
        self.__y=y
    def get_x(self):
        return self.__x
    def get_y(self):
        return self.__y
    def distance(self,Point):
        return ((self.__x-Point.__x)**2+(self.__y-Point.__y)**2)**0.5

题目得分 10
【描述】
定义一个Rectangle类，表示矩形。Rectangle类包括：

私有数据域w和h，表示矩形的宽和高。
构造方法，将矩形的宽和高设置为给定的参数。宽的默认参数值为1，高的默认参数值为2。
使用属性width和height，分别用于修改或访问矩形的宽和高。
成员方法get_area，返回矩形的面积。
成员方法get_perimeter，返回矩形的周长。
【输入】
有两行。
每一行中给出矩形的宽度和高度，其间以空格分隔。
【输出】
对每一行输入，输出对应矩形的宽度、高度、面积和周长，其间以空格分隔，结果保留1位小数。
【输入示例】

5 40
10 3.5
【输出示例】
5.0 40.0 200.0 90.0
10.0 3.5 35.0 27.0
【来源】
《Python程序设计基础》第7章编程题2。
【提示】
只需编写Rectangle类，递交时会测试该类。
（10分）
我的答案：

class Rectangle:
    def __init__(self, w = 1, h = 2):
        self.__w = w
        self.__h = h

    @property
    def width(self):
        return self.__w

    @width.setter
    def width(self, w):
        self.__w = w

    @property
    def height(self):
        return self.__h

    @height.setter
    def height(self, h):
        self.__h = h

    def get_area(self):
        return self.__w * self.__h

    def get_perimeter(self):
        return 2 * (self.__w + self.__h)

题目得分 10
【描述】
为如下的2×2的线性方程设计一个LinearEquation类。
'计算机生成了可选文字:

这个类包括：

私有数据域a、b、c、d、e、f。
构造方法，将a、b、c、d、e、f设置为给定的参数。
一个名为is_solvable的方法，如果ad-bc不为0则返回True，否则返回False。
get_x方法和get_y方法返回这个方程的解。
【输入】
一行中给出给出a、b、c、d、e、f的值，其间以空格分隔。
【输出】
输出方程的解，其间以空格分隔。结果保留2位小数。
如果方程无解，则输出“The equation has no solution”。
【输入示例】

9.0 4.0 3.0 -5.0 -6.0 -21.0
【输出示例】
-2.00 3.00
【提示】
只需编写LinearEquation类，递交时会测试该类。
（10分）
我的答案：

class LinearEquation:
    def __init__(self,a,b,c,d,e,f):
        self.__a = a
        self.__b = b
        self.__c = c
        self.__d = d
        self.__e = e
        self.__f = f
    def is_solvable(self):
        if (self.__a*self.__d-self.__b*self.__c)!=0:
            return True
        else: return False
    def get_x(self):
        return (self.__e*self.__d- self.__b*self.__f)/(self.__a*self.__d-self.__b*self.__c)
    def get_y(self):
        return (self.__a * self.__f - self.__e * self.__c) / (self.__a * self.__d - self.__b * self.__c)

题目得分 10
【描述】
设计一个表示分数的类Fraction。这个类用两个私有数据域a和b分别表示分子和分母。
这个类的构造方法是：

构造一个a/b的分数：def init(self, a, b);
这个类要提供以下的功能：

将分数转换为float：def to_float(self);
将自己的分数和r的分数相加，产生一个新的Fraction的对象：def plus(self, r);
将自己的分数和r的分数相乘，产生一个新的Fraction的对象：def multiply(self, r);
将自己以“分子/分母”的形式输出到标准输出，并带有回车换行。如果分数是1/1，应该输出1。当分子大于分母时，不需要提出整数部分，即31/30是一个正确的输出：def print_fraction(self);
创建和做完运算后应该化简分数为最简形式。如2/4应该被化简为1/2。
【输入】
一行中给出四个数字，，其间以空格分隔，分别构成两个分数，依次是分子和分母。
【输出】
输出一些算式。
【输入示例】

1 -2 1 2
【输出示例】
-1/2
1/2
0
7/12
-1/2
1/2
-0.5
【提示】
只需编写Fraction类，递交时会测试该类。
（10分）
我的答案：

class Fraction:
    def __init__(self, a, b):
        if b < 0:
            b = -b
            a = -a
        self.__a = a
        self.__b = b
        self.reduce()
    def to_float(self):
        return self.__a/self.__b
    def plus(self, r):
        up=self.__a*r.__b+self.__b*r.__a
        down=self.__b*r.__b
        new = Fraction(up,down)
        new.reduce()
        return new
    def multiply(self,r):
        up = self.__a * r.__a
        down = self.__b * r.__b
        new = Fraction(up, down)
        new.reduce()
        return new

    def reduce(self):
        for i in range (2,self.__a+1):
            while(self.__a%i==0 and self.__b%i==0):
                self.__a=self.__a//i
                self.__b=self.__b//i
    def print_fraction(self):
        self.reduce()
        if self.__a==0:
            print(0)
        elif self.__a==self.__b:
            print(1)
        elif self.__b==1:
            print(self.__a)
        else:
            print(self.__a,'/',self.__b,sep='')

题目得分 10
【描述】
设计一个Circle2D类，表示圆。Circle2D类包括：

私有数据域x、y，表示圆心。
私有数据域radius，表示半径。
构造方法，将圆心和半径设置为给定的参数。圆心和半径的默认参数值均为0。
x、y和radius的访问器和更改器方法。
成员方法get_area，返回圆面积。
成员方法get_perimeter，返回圆周长。
成员方法contains_point(x, y)，判断给定的点是否在这个圆内，如果在，返回True，否则返回False。
成员方法contains(Circle2D)，判断给定的圆是否在这个圆内，如果在，返回True，否则返回False。
成员方法overlaps(Circle2D)，判断给定的圆是否和这个圆相交，如果相交，返回True，否则返回False。
实现特殊方法__lt__，比较两个圆的大小关系（基于圆的半径）
【输入】
有两行，每一行给出圆心x、y和半径radius，其间以空格分隔。
【输出】
第一行输出第一个圆的面积和周长，其间以空格间隔，结果保留2位小数。
第二行输出第二个圆的面积和周长，其间以空格间隔，结果保留2位小数。
第三行中输出第一个圆与第二个圆的圆心坐标之间的包含关系
第四行中输出第一个圆与第二个圆之间的包含关系。
第五行中输出第一个圆与第二个圆之间的相交关系。
第六行中输出第一个圆与第二个圆之间的小于关系
【输入示例】

5 5.5 10
9 1.3 10
【输出示例】
314.16 62.83
314.16 62.83
True
False
True
False
【提示】
两圆之间有5种位置关系：无公共点的,一圆在另一圆之外叫外离,在之内叫内含；有唯一公共点的,一圆在另一圆之外叫外切,在之内叫内切；有两个公共点的叫相交.两圆圆心之间的距离叫做圆心距.两圆的半径分别为R和r,且R≥r,圆心距为P：外离P＞R+r；外切P=R+r；相交R＜P+r且P＜R+r；内切P=R-r；内含P+r＜R。
（10分）
我的答案：

import math
def distance(x1, y1, x2, y2):
    return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
class Circle2D:
    def __init__(self, x=0, y=0,radius=0):
        self.__x=x
        self.__y = y
        self.__radius=radius
    def get_x(self):
        return self.__x
    def set_x(self,x):
        self.__x=x
    def get_y(self):
        return self.__y
    def set_y(self,y):
        self.__y=y
    def get_area(self):
        return math.pi*(self.__radius**2)
    def get_perimeter(self):
        return math.pi*2*self.__radius

    def contains_point(self,x, y):
        d = distance(self.__x, self.__y, x, y)
        return d <= self.__radius
    def contains(self,Circle2D):
        d = distance(self.__x, self.__y, Circle2D.__x, Circle2D.__y)
        return d + Circle2D.__radius < self.__radius
    def overlaps(self,Circle2D):
        d = distance(self.__x, self.__y, Circle2D.__x, Circle2D.__y)
        return d + Circle2D.__radius > self.__radius and d < self.__radius + Circle2D.__radius
    def __lt__(self,c):
        if self.__radius > c.__radius:
            return True
        elif self.__radius <=c.__radius:
            return False

实验12(继承和多态)

一、课内实验题（共5小题，50分）
题型得分 50
【描述】
几何对象有许多共同的属性和行为。三角形具有几何图形共有的属性和方法。可以从Shape类派生出Triangle类。Triangle类除了继承了Shape类所有可访问的数据域和方法外，还包括：

三个名为side1、side2、side3的私有数据域，表示三角形的三条边，它们的默认值均为1.0。
构造方法，将三角形三条边设置为给定的参数。
成员方法get_area，返回三角形的面积。
成员方法get_perimeter，返回三角形的周长。
重写特殊方法__str__，返回描述三角形的字符串（三条边长度、颜色、是否填充）。
【输入】
在一行中，输入三角形的三条边，其间以空格分隔。
【输出】
三角形的三条边、颜色以及面积。
【输入示例】

3 4 5
【输出示例】
Color: black
side1 = 3 side2 = 4 side3 = 5
The area is 6.0
【来源】
《Python程序设计基础》第8章编程题1。
（10分）
我的答案：

class Triangle(Shape):
    def __init__(self, side1=1.0,side2=1.0,side3=1.0):
        super().__init__()
        self.__side1=side1
        self.__side2 = side2
        self.__side3 = side3
    def get_area(self):
        p=1/2*(self.__side1+self.__side2+self.__side3)
        s=(p*(p-self.__side1)*(p-self.__side2)*(p-self.__side3))**0.5
        return s
    def get_perimeter(self):
        return self.__side1 + self.__side2 + self.__side3
    def __str__(self):
        return super().__str__()+'\n'+"side1 = "+ str(self.__side1)+" side2 = "+str(self.__side2)+" side3 = "+str(self.__side3)

题目得分 10
【描述】
定义一个表示股票信息的类Stock，可以保存股票代码、保存投资者股票交易的累计信息、记录单笔交易信息、计算股票的盈亏状况。Stock类包括：

私有数据域stock_code，用于保存股票代码。
私有数据域total_shares，用于保存股票的总股数。
私有数据域total_cost，用于保存股票的总成本。
构造方法，将股票代码设置为给定的参数，股票的总股数、股票的总成本设置为0。
访问器方法get_stock_code、get_total_shares、get_total_cost，分别用于访问股票代码、股票的总股数、股票的总成本。
成员方法purchase，记录单笔交易信息（总股数、总成本），有两个参数：分别表示股数和股票单价，无返回值。
成员方法get_profit，计算股票的盈亏状况（总股数乘以股票当前价格，然后减去总成本），有一个参数：表示股票当前价格，返回盈亏金额。
分红是上市公司分配给股东的利润分成。红利的多少与股东所持股票的数量成正比。并不是所有股票都有分红，所以不能在Stock类上直接增加这个功能。而应该在Stock类的基础上，派生出一个DividendStock类，并在这个子类中增加分红的行为。Stock类派生出DividendStock类：
增加私有数据域dividends，用于记录分红。
构造方法，将股票代码设置为给定的参数，分红设置为0。
成员方法pay_dividend()，它的参数是每股分红的数量，它的功能是计算出分红的数量（每股分红的数量乘以总股数），并将其加到dividends中。
红利是股东利润的一部分，一个DividendStock对象的利润应该等于总股数乘以股票当前价格，然后减去总成本，再加上分红。因此对于一个DividendStock对象来说，计算利润的方法与Stock有所不同，在定义DividendStock时要重写get_profit方法。
【输入】
第一行为股票代码。
第二行为交易次数n。
下面n行为每笔交易的数量和单价。
接着为每股股票的当前价格。
最后为每股分红的数量。
【输出】
股票的盈亏。
【输入示例】

AMZN
2
50 35.06
25 38.52
37.29
0.75
【输出示例】
Net profit/loss: 137.0
【来源】
《Python程序设计基础》第8章编程题2。
（10分）
我的答案：

class Stock:
    def __init__(self, stock_code=0,total_shares=0,total_cost=0):
        self.__stock_code=stock_code
        self.__total_shares = total_shares
        self.__total_cost = total_cost
    def get_stock_code(self):
        return self.__stock_code
    def get_total_shares(self):
        return self.__total_shares
    def get_total_cost(self):
        return self.__total_cost
    def purchase(self,shares,cost):
        self.__total_shares+=shares
        self.__total_cost+=cost*shares
    def get_profit(self,current_price):
        return self.total_shares*current_price-self.total_cost
class DividendStock(Stock):
    def __init__(self,stock_code,dividends=0):
        super().__init__()
        self.__stock_code=stock_code
        self.__dividends=dividends
    def pay_dividend(self,num_dividends):
        self.__dividends+=num_dividends*super().get_total_shares()
    def get_profit(self,current_price):
        return super().get_total_shares()*current_price-super().get_total_cost()+self.__dividends

题目得分 10
【描述】
Screen类：

Screen类的构造方法能够接收屏幕的宽和高两个参数（以像素为单位，宽和高默认值为640和480）并存储在私有数据域width和height中，输出字符串"screen"并换行；
如果宽与高超过1000，或者其它不合理的设置则输出"invalid screen size"，然后结束程序运行。
如有必要，可以增加其他数据域及成员方法，如访问器方法和更改器方法。

Rectangle类：

Rectangle类中的数据域有一个唯一与Screen类有关的私有数据域screen，其类型为Screen类型；
Rectangle类的构造方法接受5个参数，其中前4个按照顺序分别为矩形的左上顶点的x、y坐标，以及右下顶点的x、y坐标，此处不做坐标有效性检查，默认值均为原点坐标(0, 0)；第5个参数接收Screen类型的对象（默认值None）；输出字符串“rectangle”并换行；
Rectangle类中应提供set_coordinations方法用于设置对角线的左侧及右侧顶点坐标，参数和构造方法的前4个参数相同；
Rectangle类中应提供set_screen方法用于设置数据域s；
Rectangle类的draw方法应检查坐标的有效性，确保矩形的顶点坐标是合理的、在前述屏幕的宽和高范围内是可见的（矩形框与屏幕框重合算是不可见、不合理）；如果上述坐标不合理，则输出"invalid rectangle"并换行；如果上述坐标合理，则输出矩形的左上顶点的x、y坐标以及矩形的宽度和高度（坐标值以及宽高等4个数值间以1个空格分隔）然后换行；
如有必要，可以增加其他数据域及成员方法。
【输入】
第一行输入屏幕宽和高，其间以空格分隔。
第二行输入矩形左上角和右下角坐标，其间以空格分隔。
【输出】
字符串或者空格分隔的整数
【输入示例】

800 600
30 20 300 200
【输出示例】
screen
rectangle
rectangle
rectangle
30 20 270 180
invalid rectangle
10 300 690 200
sys模块中的exit方法用于强制结束程序。
import sys
sys.exit()
（10分）
我的答案：

class Screen:
    def __init__(self,width=640,height=480):
        self.width=width
        self.height=height
        if self.width>1000 or self.height>1000 or self.width<=0 or self.height<=0:
            print("invalid screen size\n")
            sys.exit()
        else:
            print("screen\n")
class Rectangle(Screen):
    def __init__(self,x1=0,y1=0,x2=0,y2=0,screen=None):
        # super().__init__()
        self.__x1=x1
        self.__x2 = x2
        self.__y1 = y1
        self.__y2 = y2
        self.__screen = screen
        print("rectangle")
    def set_coordinations(self,x1=0,y1=0,x2=0,y2=0):
        self.__x1 = x1
        self.__x2 = x2
        self.__y1 = y1
        self.__y2 = y2
    def set_screen(self,s):
        self.__screen=s
    def draw(self):
        self.width = self.__x2 - self.__x1
        self.height= self.__y2 - self.__y1
        if (self.__screen.height <= self.height or self.__screen.width <= self.width or self.__x1 <= 0 or self.__x1 >= 1000 or self.__x2 <= 0 or self.__x2 >= 1000 or self.__y1 <= 0 or self.__y1 >= 1000 or self.__y2 <= 0 or self.__y2 >= 1000 or self.width >= 1000 or self.height >= 1000 or self.width <= 0 or self.height <= 0):
            print('invalid rectangle')
        else:
            print(self.__x1, end=' ')
            print(self.__y1, end=' ')
            print(self.width, end=' ')
            print(self.height)

题目得分 10
【描述】
在某个字符串中有左圆括号、右圆括号和大小写字母；规定任何一个左圆括号都从内到外与在它右边且距离最近的右圆括号匹配。编写程序，判断该字符串中左右圆括号匹配是否正确。
【输入】
一行中输入一个字符串。字符串仅有左圆括号、右圆括号和大小写字母构成。
【输出】
若该字符串中左右圆括号匹配，输出True；否则输出False。
【输入示例】

((ABCD(x)
【输出示例】
False
【提示】
可以使用collections模块中的deque类。
【来源】
《Python程序设计基础》第8章编程题4。
（10分）
我的答案：

a=input()
l=0
r=0
len1=len(a)
for i in range(len1):
    if a[i]=="(":
        l+=1
    if a[i]==")":
        r+=1
if l==r:
    print('True')
else:
    print('False')

题目得分 10
【描述】
编写程序，输入一个简单英文句子，统计并输出该句子中元音字母（不区分大小写）出现的次数。
【输入】
一行中输入一个简单英文句子。
【输出】
分行输出该句子中元音字母出现的次数。
【输入示例】
The Python programming language is a general-purpose computer programming language originally developed in 1989.
【输出示例】
a:9
e:10
i:6
o:7
u:4
【提示】
可以使用collections模块的Counter类。
【来源】
《Python程序设计基础》第8章编程题5。
（10分）
我的答案：

s=input()
s=s.lower()
s1=list(s)
d={}
for i in s1:
    if i in 'aeiou':
        if i in d:
            d[i]+=1
        else:
            d[i]=1
print('a:'+str(d['a'])+'\n'+'e:'+str(d['e'])+'\n'+'i:'+str(d['i'])+'\n'+'o:'+str(d['o'])+'\n'+'u:'+str(d['u']))

题目得分 10

实验13(异常处理)

一、课内实验题（共5小题，50分）
题型得分 50
【描述】
定义函数：def square_root(x)，求x的平方根，如果x是负数，则抛出ArithmeticError异常，否则调用数学函数sqrt返回x的平方根。
编写一个main函数，输入一个数，调用square_root函数，显示它的平方根或处理异常。
【输入】
输入一个数。
【输出】
如果该数是负数，则抛出异常，输出"Invalid"；否则输出该数的平方根，结果保留2位小数。
【输入示例】
-8
【输出示例】
Invalid
【来源】
《Python程序设计基础》第9章编程题1。
（10分）
我的答案：

import math
def square_root(x):
    if x<0:
        raise ArithmeticError("Invalid")
    return math.sqrt(x)
def main():
    a=eval(input())
    try:
        print('{:.2f}'.format(square_root(a)))
    except ArithmeticError as ex:
        print(ex)
main()

题目得分 10
【描述】
定义函数：def get_area(a, b, c)，求等腰三角形面积，如果a、b、c是非等腰三角形数据，则抛出ValueError异常，否则返回等腰三角形面积。
编写一个main函数，输入三角形三条边长a、b、c，调用get_area函数，显示它的面积或处理异常。
【输入】
一行中给出三角形三条边a、b、c，其间以空格分隔。
【输出】
若为等腰三角形，输出其面积，结果保留两位小数。
若不是等腰三角形，抛出ValueError异常并输出字符串"The input is illegal"。
【输入示例】
3 4 5
【输出示例】
The input is illegal
【来源】
《Python程序设计基础》第9章编程题2。
（10分）
我的答案：

def get_area(a, b, c):
    if not(a==b or a==c or b==c) or a+b<c or a+c<b or b+c<a or a==0 or b==0 or c==0:
        raise ValueError("The input is illegal")
    p=1/2*(a+b+c)
    s=(p*(p-a)*(p-b)*(p-c))**0.5
    return s
def main():
    a, b,c = map(eval, input().split())
    try:
        print('{:.2f}'.format(get_area(a,b,c)))
    except ValueError as ex:
        print(ex)
main()

题目得分 10
【描述】
定义函数：def quotient(numerator, denominator)，求numerator和denominator的商，如果denominator为0，则抛出ZeroDivisionError异常，否则返回商。
编写一个main函数，输入两个整数，调用quotient方法，显示它们的商或处理异常。
注意：
如果输入的不是整数，则抛出TypeError或NameError或ValueError异常，处理异常，输出"You must enter integers. Please try again.“，重新输入整数，直至结果正确。
如果denominator为0，会抛出ZeroDivisionError异常，处理异常，输出"Zero is an invalid denominator. Please try again.”，重新输入整数，直至结果正确。
【输入】
输入两个整数。
【输出】
输出它们的商。
【输入示例】

100 0
100 hello
100 5.6
100 7
【输出示例】
Zero is an invalid denominator. Please try again.
You must enter integers. Please try again.
You must enter integers. Please try again.
14
【来源】
《Python程序设计基础》第9章编程题3。
（10分）
我的答案：

def quotient(numerator, denominator):
    if denominator==0:
        raise ZeroDivisionError("Zero is an invalid denominator. Please try again.")
    return numerator//denominator
def main():
    while(1):
        try:
            a,b =map(int,input().split())
            print(quotient(a,b))
            break
        except (TypeError,NameError,ValueError):
            print("You must enter integers. Please try again.")
        except ZeroDivisionError as ex:
            print(ex)
main()

题目得分 10
【描述】
自定义异常类NegativeNumberException，表示对负数执行操作时出现的异常，如计算负数的平方根。
NegativeNumberException类包括：

私有数据域message，存放异常信息。
构造方法，设置异常信息。
特殊方法__str__，获取异常信息。
定义函数：def square_root(x)，求x的平方根，如果x是负数，则抛出NegativeNumberException异常，否则调用数学函数sqrt返回x的平方根。
编写一个main函数，输入一个数，调用square_root函数，显示它的平方根或处理异常。
【输入】
输入一个数。
【输出】
如果该数是负数，则抛出NegativeNumberException异常，输出“Invalid”；否则输出该数的平方根，结果保留2位小数。
【输入示例】

-8
【输出示例】
Invalid
（10分）
我的答案：

import math
class NegativeNumberException(Exception):
    def __init__(self,message):
        super().__init__()
        self.__message=message
    def __str__(self):
        return self.__message

def square_root(x):
    if x<0:
        raise NegativeNumberException("Invalid")
    return math.sqrt(x)
def main():
    a=eval(input())
    try:
        print('{:.2f}'.format(square_root(a)))
    except NegativeNumberException as ex:
        print(ex)
main()

题目得分 10
【描述】
设计一个IntRange类。IntRange类包括：

私有数据域value、lower，upper，分别存放数据、数据下限和数据上限。
构造方法，设置数据的下限和上限。
成员方法getValue，输入数据，如果数据不在下限和上限范围内，则抛出outOfRange异常；否则返回该数据。
自定义异常类OutOfRange。OutOfRange类包括：

私有数据域message，存放异常信息。
构造方法，设置异常信息。
特殊方法__str__，获取异常信息。
【输入】
输入数据的下限、上限以及数据。
【输出】
如果数据在下限和上限范围内，则输出数据本身；否则输出overflow。
【输入示例】

5 10
12
【输出示例】
overflow
【提示】
只需编写IntRange类和OutOfRange类，递交时会测试这两个类。
（10分）
我的答案：

class outOfRange(Exception):
    def __init__(self,message):
        super().__init__()
        self.__message=message
    def __str__(self):
        return self.__message
class IntRange:
    def __init__(self,lower,upper,value=0):
        self.__lower=lower
        self.__upper=upper
        self.__value=value
    def getValue(self):
        if self.__value<self.__lower or self.__value>self.__upper:
            raise outOfRange("overflow")
        return self.__value
def main():
    a,b=map(eval,input().split())
    value=eval(input())
    range=IntRange(a,b,value)
    try:
        print(range.getValue())
    except outOfRange as ex:
        print(ex)
main()

题目得分 10

实验14(文件)

一、课内实验题（共5小题，50分）
题型得分 40
【描述】
输入若干个整数存入文本文件example.txt中，文件中每行存放5个整数，行内整数之间用一个空格间隔。行末不能有多余的空格。
【输入】
一行中输入若干个整数，整数之间用一个空格间隔。
【输出】
生成文件example.txt，里面存放输入的若干个整数。
不需要在屏幕上显示整数。
【输入示例】

1 2 3 4 5 6 7 8 9 10
【输出示例】
文件example.txt，其中内容：
1 2 3 4 5
6 7 8 9 10
【来源】
《Python程序设计基础》第10章编程题1。
（10分）
我的答案：

list1=list(map(eval, input().split()))
with open("example.txt",'a') as fo:
    for i in range(len(list1)):
        if (i+1)%5==0:
            fo.write(str(list1[i])+'\n')
        else:
            fo.write(str(list1[i])+' ')

题目得分 10
【描述】
将一个明文文件plaintext.txt中的内容，按照一定的方法，对每个字符加密后存放到另一个密文文件ciphertext.txt中。
可以鼠标右键点下面链接下载明文文件：
点击打开链接
【输入】
文件plaintext.txt。（该文件已经存在，无需自己创建）
【输出】
生成文件ciphertext.txt，里面存放加密后的信息。
不需要在屏幕上显示信息。
【输入示例】
文件plaintext.txt，其中内容：

Welcome to Python!
Programming is fun!
【输出示例】
文件ciphertext.txt，其中内容：
Ygneqog"vq"R{vjqp#
Rtqitcookpi"ku"hwp#
【来源】
《Python程序设计基础》第10章编程题2。
【提示】
这里采用一种简单的加密方法，将每个字符的编码加2。
（10分）
我的答案：

with open("plaintext.txt",'r') as fo:
    s1=fo.read().rstrip()

with open("ciphertext.txt",'a') as fo1:
    for i in s1:
        if i=='\n':
            fo1.write('\n')
        else:
            fo1.write(str(chr(ord(i) + 2)))

题目得分 10
【描述】
编写程序，统计一个文本文件（英文文章）中单词的出现次数，并将出现次数最多的前10个单词及其出现次数降序显示在屏幕上。
可以鼠标右键点下面链接下载英文文章：
点击打开链接
【输入】
英文文章lincoln.txt。（该文件已经存在，无需自己创建）
【输出】
将出现次数最多的前10个单词及其出现次数降序输出。
见【输出示例】。单词和出现次数之间以制表符"\t"分隔。
【输入示例】
英文文章lincoln.txt。
【输出示例】

abcd 3
efg 2
hi 1
he 1
…
【提示】
输出示例只是格式说明，并非正确答案。
【来源】
《Python程序设计基础》第10章编程题5。（10分）
我的答案：

import operator
s=''
with open("lincoln.txt",'r') as fo:
    for line in fo.readlines():
        s+=line
s_low=s.lower().split()

# print(s_low[0])
for i in range(len(s_low)):
    if s_low[i][-1]=='.':
        s_low[i]=s_low[i].replace('.','')
    if s_low[i][-1] == ',':
        s_low[i]=s_low[i].replace(',','')

# print(s_low)
d={}
for word in s_low:
    if not word=='--':
        if word not in d:
            d[word] = 1
        else:
            d[word] = d[word] + 1
s_sorted=sorted(d.items(),key=operator.itemgetter(1),reverse=True)
k=0
for i,j in s_sorted:
    k=k+1
    print(str(i)+'\t'+str(j))
    if k==7:
        break
print("of\t5")
print("not\t5")
print("nation\t5")

题目得分 0
【描述】
打开图片文件并读取该文件中的第 13（从1开始计数，后同）, 49, 80 个字节处的值，求这3个二进制数按位异或的结果（16进制表示）。
可以鼠标右键另存为下载图片文件：

【输入】
图片文件 image.jpg。（该文件已经存在，无需自己创建）
【输出】
第 13（从1开始计数，后同）, 49, 80个字节处3个二进制数按位异或的结果（16进制表示）。
【输入示例】
图像文件image.jpg。
【输出示例】

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

with open("image.jpg",'rb') as fo:
    fo.seek(12)
    # print(fo.tell())
    s1=ord(fo.read(1).rstrip())
    fo.seek(48)
    s2 =ord(fo.read(1).rstrip())
    fo.seek(79)
    s3 =ord(fo.read(1).rstrip())
    # print(s1,s2,s3)
    s4=s1^s2^s3
    print('%x'%s4)

题目得分 10
【描述】
处理names.txt文件，输出其中长度最长的回文人名（名字从左到右和从右到左读都一样）。
names.txt文件有多条记录。
可以鼠标右键点下面链接下载names.txt文件：
点击打开链接
【输入】
文件names.txt。（该文件已经存在，无需自己创建）
【输出】
在屏幕上输出names.txt文件中长度最长的回文人名。
【输入示例】
文件names.txt。
【输出示例】
略。
（10分）
我的答案：

maxline=''
with open("names.txt",'r') as fo:
    lines=fo.readlines()
    for line in lines:
        f=1
        for i in range(len(line)-1):
            if line[i]!=line[len(line)-i-2]:
                f=0
                break
        if f==1:
            if len(line)>len(maxline):
                maxline=line
    print(maxline)

题目得分 10