Python对象和类

Python对象和类

课内实验11(对象和类)
班级： 学号： 2020212205090 姓名： 缪纪 得分： 50
一、课内实验题（共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
【输出示例】
32.10
【来源】
《Python程序设计基础》第7章编程题1。
【提示】
只需编写Point类，递交时会测试该类。
（10分）
我的答案：
#coding=utf-8
import math
class Point(object):
def init(self,xx=0.0,yy=0.0):
self.__x=xx
self.__y=yy

def get_x(self):
    return self.__x

def get_y(self):
    return self.__y

def distance(self,pt):
    xDiff=self.__x-pt.__x
    yDiff=self.__y-pt.__y
    return math.sqrt(xDiff**2+yDiff**2)

题目得分 10
参考答案：
import math
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, p):
    return math.sqrt((self.__x - p.__x) ** 2 + (self.__y - p.__y) ** 2)

def main():
x, y = map(float, input().split())
p1 = Point(x, y)
x, y = map(float, input().split())
p2 = Point(x, y)
print("%.2f" % p1.distance(p2))

main()
【描述】
定义一个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分）
我的答案：
#coding=utf-8
import math

class Rectangle(object):

def __init__(self,ww=1.0,hh=2.0):
    self.width=ww
    self.height=hh
def get_area(self):
    return self.width*self.height
def get_perimeter(self):
    return (self.width+self.height)*2

题目得分 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)

def main():
w, h = map(float, input().split())
rect1 = Rectangle()
rect1.width = w
rect1.height = h
w, h = map(float, input().split())
rect2 = Rectangle(w, h)
print("%.1f %.1f %.1f %.1f" % (rect1.width, rect1.height, rect1.get_area(), rect1.get_perimeter()))
print("%.1f %.1f %.1f %.1f" % (rect2.width, rect2.height, rect2.get_area(), rect2.get_perimeter()))

main()
【描述】
为如下的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分）
我的答案：
#coding=utf-8
import math

class LinearEquation(object):
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):
return (self.aself.d-self.bself.c!=0)
def get_x(self):
return (self.eself.d-self.bself.f)/(self.aself.d-self.bself.c)
def get_y(self):
return (self.aself.f-self.eself.c)/(self.aself.d-self.bself.c)
题目得分 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):
    return True if self.__a * self.__d - self.__b * self.__c != 0 else 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)

def main():
a, b, c, d, e, f = map(float, input().split())
equation = LinearEquation(a, b, c, d, e, f)
if equation.is_solvable():
print("%.2f %.2f" % (equation.get_x(), equation.get_y()))
else:
print(“The equation has no solution”)

main()
【描述】
设计一个表示分数的类Fraction。这个类用两个int类型的变量分别表示分子和分母。
这个类的构造方法是：

构造一个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分）
我的答案：
#coding=utf-8
import math

class Fraction(object):
def init(self,a,b):
self.a=a
self.b=b
self.a=int(self.a)
self.b=int(self.b)
def to_float(self):
return self.a/self.b
def plus(self, r):
down=self.br.b
up=self.ar.b+r.aself.b
return Fraction(up/math.gcd(up,down),down/math.gcd(up,down))
def multiply(self, r):
down=self.br.b
up=self.a*r.a
return Fraction(up/math.gcd(up,down),down/math.gcd(up,down))

def print_fraction(self):
    if(self.b<0):
        self.b=-self.b
        self.a=-self.a
    if(self.a!=0):
        print(int(self.a/math.gcd(self.a,self.b)),end="")
        print("/",end="")
        print(int(self.b/math.gcd(self.a,self.b)))
    else:
        print("0")

题目得分 10
参考答案：
class Fraction:
def init(self, a, b):
if b < 0:
a *= -1
b *= -1
self.__a = a
self.__b = b
self.__reduce()

def to_float(self):
    return self.__a / self.__b

def plus(self, r):
    n = self.__a * r.__b + self.__b * r.__a
    d = self.__b * r.__b
    result = Fraction(n, d)
    result.__reduce()
    return result

def multiply(self, r):
    n = self.__a * r.__a
    d = self.__b * r.__b
    result = Fraction(n, d)
    result.__reduce()
    return result

def print_fraction(self):
    if self.__a == 0:
        print(0)
    if self.__b == 1:
        print(self.__a)
    else:
        print(self.__a, '/', self.__b, sep = '')
        
def __reduce(self):
    g = self.__gcd()
    if g != 1:
        self.__a //= g
        self.__b //= g

def __gcd(self):
    n = self.__a
    d = self.__b
    if n == 0:
        return d
    if n < 0:
        n = -n
    while(True):
        r = n % d
        if r == 0:
            break
        n = d
        d = r
    return d 

def main():
line = input().split()
a = Fraction(int(line[0]), int(line[1]))
b = Fraction(int(line[2]), int(line[3]))
a.print_fraction()
b.print_fraction()
a.plus(b).print_fraction()
a.multiply(b).plus(Fraction(5, 6)).print_fraction()
a.print_fraction()
b.print_fraction()
print(a.to_float())

main()
【描述】
设计一个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分）
我的答案：
#coding=utf-8
import math

class Circle2D(object):
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 get_y(self):
return self.y
def get_area(self):
return self.radius**2math.pi
def get_perimeter(self):
return self.radius2*math.pi
def contains_point(self,x,y):
distance=((self.x-x)**2+(self.y-y)**2)**0.5
return(distance def contains(self,Circle2D):
distance=((self.x-Circle2D.x)**2+(self.y-Circle2D.y)**2)**0.5
return(Circle2D.radius def overlaps(self,Circle2D):
distance=((self.x-Circle2D.x)**2+(self.y-Circle2D.y)**2)**0.5
return(abs(self.radius-distance) def lt (self,other):
return (self.radius 题目得分 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 get_y(self):
    return self.__y

def get_radius(self):
    return self.__radius

def set_x(self, x):
    self.__x = x
    
def set_y(self, y):
    self.__y = y

def set_radius(self, radius):
    self.__radius = radius

def get_perimeter(self):
    return 2 * self.__radius * math.pi

def get_area(self):
    return self.__radius ** 2 * math.pi

def contains_point(self, x, y):
    d = distance(self.__x, self.__y, x, y)
    return d <= self.__radius

def contains(self, c):
    d = distance(self.__x, self.__y, c.__x, c.__y)
    return d + c.__radius < self.__radius 

def overlaps(self, c):
    d = distance(self.__x, self.__y, c.__x, c.__y)
    return d + c.__radius > self.__radius and d < self.__radius + c.__radius

def __lt__(self, another): 
    return self.__cmp__(another) < 0

# Compare two numbers
def __cmp__(self, another): 
    if self.__radius > another.__radius:
        return 1
    elif self.__radius < another.__radius:
        return -1
    else:
        return 0        

def main():
x1, y1, radius1 = (float(x) for x in input().split())
x2, y2, radius2 = (float(x) for x in input().split())
c1 = Circle2D(x1, y1, radius1)
c2 = Circle2D(x2, y2, radius2)
print("%.2f %.2f" % (c1.get_area(), c1.get_perimeter()))
print("%.2f %.2f" % (c2.get_area(), c2.get_perimeter()))
print(c1.contains_point(c2.get_x(), c2.get_y()))
print(c1.contains(c2))
print(c1.overlaps(c2))
print(c1 < c2)

main()
课内实验题，第11套，第01题 总分 10 得分 10
详细：
正确 用例1运行：通过
用例2运行：通过
用例3运行：通过
10 10
课内实验题，第11套，第02题 总分 10 得分 10
详细：
正确 用例1运行：通过
用例2运行：通过
10 10
课内实验题，第11套，第03题 总分 10 得分 10
详细：
正确 用例1运行：通过
用例2运行：通过
10 10
课内实验题，第11套，第04题 总分 10 得分 10
详细：
正确 用例1运行：通过
用例2运行：通过
用例3运行：通过
10 10
课内实验题，第11套，第05题 总分 10 得分 10
详细：
正确 用例1运行：通过
用例2运行：通过
10 10