Python初始学习（十）

1.【描述】
设计一个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

【提示】
只需编写Point类，递交时会测试该类。

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()

2.【描述】
定义一个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

【提示】
只需编写Rectangle类，递交时会测试该类。

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()

3.【描述】
为如下的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类，递交时会测试该类。

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()

 4.【描述】
设计一个表示分数的类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类，递交时会测试该类。

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)
        elif 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()

5.【描述】
设计一个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。

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

    def __le__(self, another): 
        return self.__cmp__(another) <= 0
    
    def __eq__(self, another): 
        return self.__cmp__(another) == 0
    
    def __ne__(self, another): 
        return self.__cmp__(another) != 0

    def __gt__(self, another): 
        return self.__cmp__(another) > 0

    def __ge__(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()

6.【描述】 
几何对象有许多共同的属性和行为。三角形具有几何图形共有的属性和方法。可以从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

class Shape:
    def __init__(self, color = "black"):
        self.__color = color
    def get_color(self):
        return self.__color
    def set_color(self, color):
        self.__color = color
    def __str__(self):
        return "Color: " + self.__color
    def get_area(self):
        pass

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):
        s = (self.__side1 + self.__side2 + self.__side3) / 2;
        return (s * (s - self.__side1) * (s - self.__side2) * (s - self.__side3)) ** 0.5

    def __str__(self):
        return super().__str__() + "\nside1 =  " + str(self.__side1) + " side2 = " + \
               str(self.__side2) + " side3 = " + str(self.__side3)

def main():
    line = input().split()
    side1 = eval(line[0])
    side2 = eval(line[1])
    side3 = eval(line[2])
    triangle = Triangle(side1, side2, side3)
    print(triangle)
    print("The area is", triangle.get_area())

main()

7.【描述】
定义一个表示股票信息的类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

class Stock:
    def __init__(self, stock_code):
        self.__stock_code = stock_code
        self.__total_shares = 0
        self.__total_cost = 0.0

    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, price_per_share):
        self.__total_shares += shares;
        self.__total_cost += shares * price_per_share

    def get_profit(self, current_price):
        market_value = self.__total_shares * current_price
        return market_value - self.__total_cost

class DividendStock(Stock):
    def __init__(self, stock_code):
        super().__init__(stock_code)
        self.__dividends = 0.0

    def pay_dividend(self, amount_per_share):
        self.__dividends += amount_per_share * super().get_total_shares();

    def get_profit(self, current_price):
        return super().get_profit(current_price) + self.__dividends

def main():
    stock_code = input()
    current_stock = DividendStock(stock_code)
    n = int(input())
    for i in range(n):
        num_shares, price_per_share = (float(x) for x in input().split())
        current_stock.purchase(num_shares, price_per_share)
    current_price = float(input())
    amount_per_share = float(input())
    current_stock.pay_dividend(amount_per_share)
    profit = current_stock.get_profit(current_price)
    print("Net profit/loss:", profit)

main()

8.【描述】
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()

import sys
class Screen:
    def __init__(self, width=640, height=480):
        if (width <= 0 or width > 1000) or (height <= 0 or height > 1000):
            print("invalid screen size")
            sys.exit()
        else:
            self.__width = width
            self.__height = height
        print("screen")

    def set_width(self, width):
        if width <= 0 or width > 1000:
            print("invalid screen size")
            sys.exit()
        else:
            self.__width = width

    def set_height(self, height):
        if height <= 0 or height > 1000:
            print("invalid screen size")
            sys.exit()
        else:
            self.__height = height

    def get_width(self):
        return self.__width

    def get_height(self):
        return self.__height

class Rectangle:
    def __init__(self, x1=0, y1=0, x2=0, y2=0, screen=None):
        self.__left_x = x1
        self.__left_y = y1
        self.__right_x = x2
        self.__right_y = y2
        self.__screen = screen
        print("rectangle")

    def set_coordinations(self, x1, y1, x2, y2):
        self.__left_x = x1
        self.__left_y = y1
        self.__right_x = x2
        self.__right_y = y2

    def set_screen(self, screen):
        self.__screen = screen

    def draw(self):
        if 0 < self.__left_x < self.__right_x and 0 < self.__left_y < self.__right_y and \
           self.__right_x < self.__screen.get_width() and \
           self.__right_y < self.__screen.get_height():
            print(self.__left_x, self.__left_y, self.__right_x - self.__left_x, self.__right_y - self.__left_y)
        else:
            print("invalid rectangle")

def main():
    line = input().split()
    width = float(line[0])
    height = float(line[1])
    screen = Screen(width, height)
    left_x,  left_y, right_x, right_y = (eval(x) for x in input().split())
    r1 = Rectangle(left_x, left_y, right_x, right_y, screen)
    rs = [Rectangle(), Rectangle()]
    rs[1].set_coordinations(10, 300, 700, 500)
    rs[1].set_screen(screen)
    r1.draw()
    for i in range(2):
        rs[i].set_screen(screen)
        rs[i].draw()

main()

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

((ABCD(x)

【输出示例】

False

【提示】
可以使用collections模块中的deque类。

#coding=utf-8
from collections import deque
def match(expr):
    LEFT = ('(')  # 左圆括号
    RIGHT = (')') # 右圆括号
    stack = deque()
    for brackets in expr:           # 遍历字符串
        if brackets in LEFT:        # 当前字符为左圆括号
            stack.append(brackets)  # 左圆括号入栈
        elif brackets in RIGHT:     # 当前字符为右圆括号
            # 当前栈空或右圆括号减去左圆括号的值不等于1
            # not stack判断是否栈空，stack[-1]得到栈顶的值
            if not stack or not ord(brackets) - ord(stack[-1]) == 1:
                return False
            stack.pop()     # 删除左括号
    return not stack # 如果栈空返回True，否则返回False

def main():
    line = input()
    print(match(line))

main()

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类。

from collections import Counter
line = input()
c = Counter(line.lower())
lst = sorted(list(c.items()))
for t in lst:
    if t[0] in ('a', 'e', 'i', 'o', 'u'):
        print("%s:%d" % (t[0], t[1]))