Python第三周习题集

Posted 2020-10-27 zl666

# 工资结算系统 1. 部门经理 1.5万元/月  2. 程序员 工作时间  150元/小时  3.销售员 1200底薪，+ %5销售额的提成
# 给你员工，得出工资。  员工类，父类  下面3类子类。
#我写的


class Staff(object):

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age


class Department_manager(Staff):

    def __init__(self, name, age, salary):
        super().__init__(name, age)
        self._salary = salary

    @property
    def salary(self):
        return self._salary

    def get_money(self):
        print(‘%s岁的%s工作了一个月挣了%s‘ % (self._age, self._name, self._salary))


class Programer(Staff):

    def __init__(self, name, age, salary):
        super().__init__(name, age)
        self._salary = salary

    @property
    def salary(self):
        return self._salary

    def get_money(self, time):
        print(‘%s岁的%s工作了一个月共%s小时挣了%s‘ % (self._age, self._name, time, self._salary * time))


class Salesman(Staff):

    def __init__(self, name, age, sale):
        super().__init__(name, age)
        self._sale = sale

    @property
    def salary(self):
        return self._sale

    def get_money(self):
        salary = self._sale * 5 / 100 + 1200
        print(‘销售员%s一个月挣了%s‘ % (self._name, salary))


def main():
    which = str(input(‘请输入员工类型：部门经理/程序员/销售员‘))
    if which == ‘部门经理‘:
        name = input(‘请输入名字‘)
        age = input(‘请输入年龄‘)
        man1 = Department_manager(name, age, ‘1.5万元‘)
        print(man1.get_money())
    elif which == ‘程序员‘:
        name = input(‘请输入名字‘)
        age = input(‘请输入年龄‘)
        man2 = Programer(name, age, 150)
        time = int(input(‘请输入工作了多少小时‘))
        print(man2.get_money(time))
    elif which == ‘销售员‘:
        name = input(‘请输入名字‘)
        age = input(‘请输入年龄‘)
        sale = int(input(‘请输入销售额‘))
        man3 = Salesman(name, age, sale)
        print(man3.get_money())


if __name__ == ‘__main__‘:
    main()

 抽象类

　　Python没有从语言层面支持抽象类的概念，我们可以从abc模块来制造抽象类的效果。

　　在定义类的时候，通过指定metaclass=ABCMeta可以将类声明为抽象类

　　抽象类是不能创建对象的，抽象类只是拿来被继承的，给其他类继承

　　abc模块中还有一个叫abstractmethon，通过这个包装器，可以将方法包装为抽象方法，必须要求子类重写。

rom abc import ABCMeta, abstractmethod


class Employee(object, metaclass=ABCMeta):
    """员工"""

    def __init__(self, name, age):
        """初始化方法"""
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @abstractmethod  # 变型为抽象类，以下的子类继承这个的时候，必须重写这个方法。
    def get_salary(self):
        """计算月薪"""
        pass


class Manager(Employee):

    def __init__(self, name, age):
        super().__init__(name, age)

    def get_salary(self):
        return 15000


class Programer(Employee):

    def __init__(self, name, age):
        super().__init__(name, age)
        self._working_hour = 0

    @property
    def working_hour(self):
        return self._working_hour

    # 非必要属性，通过setter方法给出，必要属性，通过属性给出，不轻易修改
    @working_hour.setter
    def working_hour(self, working_hour):
        self._working_hour = working_hour if working_hour > 0 else 0

    def get_salary(self):
        return self._working_hour * 150


class Salesman(Employee):

    def __init__(self, name, age):
        super().__init__(name, age)
        self._sales = 0

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self, sales):
        self._sales = sales if sales > 0 else 0

    def get_salary(self):
        return 1200 + self._sales * 5 / 100


def main():
    emps = [
        Manager(‘曹宇‘, 22), Programer(‘杨茜然‘, 22),
        Manager(‘张超‘, 22), Programer(‘李西北‘, 22),
        Salesman(‘刘家咯‘, 22)
    ]
    for emp in emps:
        # 识别类型,很重要*******
        if isinstance(emp, Programer):
            emp.working_hour = int(input(‘请输入%s本月工作时间：‘ % emp.name))
        elif isinstance(emp, Salesman):
            emp.sales = int(input(‘请输入%s本月销售额：‘ % emp.name))
        # 同样是接受get_salary这个消息，但是不用员工表现出了不同行为
        # 因为三个子类都重写了这个方法，所以这个方法会表现出多态行为
        print(‘%s本月工资为：￥%.2f元‘ % (emp.name, emp.get_salary()))


if __name__ == ‘__main__‘:
    main()

静态方法

　　是用来发给这个类的爸爸的，不是发给这个类的。有两种方法。

　　[email protected]

　　[email protected] 下面这个比上面这个多了一个参数，(cls)

from math import sqrt


class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    # 静态方法， 用以发给类，不是发给对象的。就是发给它爸爸的。
    # @staticmethod   # @classmethod  也是发给类的，区别，
    # def is_valid(a, b, c):
    #     return a + b > c and a + c > b and b + c > a

    @classmethod  # @classmethod  也是发给类的，区别，
    def is_valid(cls, a, b, c):
        return a + b > c and a + c > b and b + c > a

    @property
    def perimeter(self):
        return self._a + self._b + self._c

    @property
    def area(self):
        half = self.perimeter / 2
        return sqrt(half * (half - self._a) * (half - self._b) * (half - self._c))


def main():
    a = b = c = 1
    if Triangle.is_valid(a, b, c):  # 静态方法。
        t = Triangle(a, b, c)
        print(t.perimeter)  # 对象来执行
        # 或者用 (Triangle.perimeter(t))  类来执行，传入参数。
        print(t.area)
    else:
        print(‘无法构成三角形！‘)


if __name__ == ‘__main__‘:
    main()

 贪吃蛇

import pygame
from random import randint
from abc import ABCMeta, abstractmethod

BLACK_COLOR = (0, 0, 0)
FOOD_COLOR = (236, 111, 187)
GREEN_COLOR = (0, 255, 0)

UP = 0
RIGHT = 1
DOWN = 2
LEFT = 3


class GameObject(object, metaclass=ABCMeta):

    def __init__(self, x=0, y=0, color=BLACK_COLOR):
        self._x = x
        self._y = y
        self._color = color

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y

    @property
    def color(self):
        return self._color

    @abstractmethod  # 后面继承的子类都必须重写此方法，不然报错
    def draw(self, screen):
        pass


class SnakeNode(GameObject):  # 蛇节

    def __init__(self, x, y, size, color=GREEN_COLOR):
        """
        x y 为坐标，size为宽高。
        :param x:
        :param y:
        :param size:
        :param color:
        """
        super(SnakeNode, self).__init__(x, y, color)
        self._size = size

    @property
    def size(self):
        return self._size

    def draw(self, screen):
        """
        画蛇的节点，其中，位置，由左上的位置坐标和宽高组成。0，表示实心。
        :param screen:
        :return:
        """
        pygame.draw.rect(screen, self._color, [self._x, self._y, self._size, self._size], 0)
        pygame.draw.rect(screen, BLACK_COLOR, [self._x, self._y, self._size, self._size], 1)


class Snake(GameObject):

    def __init__(self):
        """由蛇节组成??"""
        super(Snake, self).__init__()
        self._dir = LEFT
        self._nodes = []
        self._alive = True
        for index in range(5):
            node = SnakeNode(290 + index * 20, 250, 20)
            self._nodes.append(node)

    @property
    def head(self):
        return self._nodes[0]

    @property
    def dir(self):
        return self._dir

    @property
    def alive(self):
        return self._alive

    def collide(self, wall):
        """撞到墙返回真，否则返回False"""
        head = self.head
        if head.x < wall.x or head.x + head.size > wall.x + wall.width            or head.y < wall.y or head.y + head.size > wall.y + wall.height:
            self._alive = False

    def eat_food(self, food):
        if self.head.x == food.x and self.head.y == food.y:
            tail = self._nodes[-1]
            self._nodes.append(tail)
            return True
        return False

    def draw(self, screen):
        for node in self._nodes:
            node.draw(screen)

    def move(self):
        if self._alive:
            snake_dir = self._dir
            x, y, size = self.head.x, self.head.y, self.head.size
            if snake_dir == UP:
                y -= size
            elif snake_dir == RIGHT:
                x += size
            elif snake_dir == DOWN:
                y += size
            else:
                x -= size
            new_head = SnakeNode(x, y, size)
            self._nodes.insert(0, new_head)
            self._nodes.pop()

    def change_dir(self, new_dir):
        if (self._dir + new_dir) % 2 != 0:
            self._dir = new_dir


class Wall(GameObject):

    def __init__(self, x, y, width, height, color=BLACK_COLOR):
        super(Wall, self).__init__(x, y, color)
        self._width = width
        self._height = height

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

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

    def draw(self, screen):
        pygame.draw.rect(screen, self._color, [self._x, self._y, self._width, self._height], 5)


class Food(GameObject):

    def __init__(self, x, y, size, color=FOOD_COLOR):
        super(Food, self).__init__(x, y, color)
        self._size = size
        self._hidden = False

    def draw(self, screen):
        """让食物闪烁起来"""
        if not self._hidden:
            pygame.draw.circle(screen, self._color,
                               (self._x + self._size // 2, self._y + self._size // 2),
                               self._size // 2, 0)
        self._hidden = not self._hidden


def main():
    def refresh():
        """刷新游戏窗口"""
        screen.fill([242, 242, 242])
        snake.draw(screen)
        wall.draw(screen)
        food.draw(screen)
        pygame.display.flip()

    def handle_key_event(key_event):
        """接受按键事件"""
        key = key_event.key
        if key == pygame.K_F2:
            reset_game()
        else:
            if snake.alive:
                new_dir = snake.dir
                if key == pygame.K_w:
                    new_dir = UP
                elif key == pygame.K_d:
                    new_dir = RIGHT
                elif key == pygame.K_s:
                    new_dir = DOWN
                elif key == pygame.K_a:
                    new_dir = LEFT
                if new_dir != snake.dir:
                    snake.change_dir(new_dir)

    def create_food():
        row = randint(0, 29)
        col = randint(0, 29)
        return Food(10 + 20 * row, 10 + 20 * col, 20)

    def reset_game():
        nonlocal food, snake
        food = create_food()
        snake = Snake()

    wall = Wall(10, 10, 600, 600)
    food = create_food()
    snake = Snake()
    pygame.init()
    pygame.display.set_caption(‘贪吃蛇‘)
    screen = pygame.display.set_mode([620, 620])  # 左上角是坐标原点。
    screen.fill([242, 242, 242])
    pygame.display.flip()
    clock = pygame.time.Clock()  # 帧数，游戏每秒的刷新次数。帧数越高越好，但是要机器能跟上。
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                handle_key_event(event)  # 调用按键函数
        if snake.alive:
            refresh()  # 调用刷新函数
        clock.tick(10)  # 刷新次数
        if snake.alive:
            snake.move()
            snake.collide(wall)
            if snake.eat_food(food):
                food = create_food()
    pygame.quit()


if __name__ == ‘__main__‘:
    main()

分子分母的重写

from math import gcd


class Fraction(object):

    def __init__(self, num=1, den=1):  # 后面跟两个下划线，是共有的，如果后面有一个或没有，才是私有的。
        """
        分子分母
        :param num:分子
        :param den: 分母
        """
        if den == 0:
            raise ValueError(‘分母不能为零‘)  # 你敢让他为零，我就死给你看
        self._num = num
        self._den = den
        self.normalize()  # 自动调用正常化
        self.simplify()   # 自动调用化简

    @property
    def num(self):
        return self._num

    # @num.setter
    # def num(self, num):
    #     self._num = num

    @property
    def den(self):
        return self._den

    # @den.setter
    # def den(self, den):
    #     self._den = den

    def add(self, other):
        """加法"""
        return Fraction(self._num * other.den + self._den * other.num,
                        self._den * other.den)

    def __add__(self, other):
        """运算符重载/重写"""
        return self.add(other)

    def sub(self, other):
        """减法"""
        return Fraction(self._num * other.den - self._den * other.num,
                        self._den * other.den)

    def __sub__(self, other):
        return self.sub(other)

    def mul(self, other):
        """乘法"""
        return Fraction(self._num * other.num ,
                        self._den * other.den)

    def __mul__(self, other):
        return self.mul(other)

    def truediv(self, other):
        """除法"""
        return Fraction(self._num * other.den ,
                        self._den * other.num)

    def __truediv__(self, other):
        return self.truediv(other)

    def simplify(self):
        """
        化简
        :return:
        """
        if self._num != 0 and self._den != 1:
            factor = gcd(abs(self._num), abs(self._den))
            if factor > 1:
                self._den //= factor
                self._num //= factor

    def normalize(self):
        """
        正规化
        :return:
        """
        if self._den < 0:
            self._num = -self._num
            self._den = -self._den

    def __str__(self):
        """方法的自动调用"""
        if self._num == 0:
            return ‘0‘
        elif self._den == 1:
            return str(self._num)
        else:
            return ‘%d/%d‘ % (self._num, self._den)


def main():
    f1 = Fraction(-1, -3)
    f2 = Fraction(4, 2)
    f3 = Fraction(0, 4)
    print(f1 + f2)
    print(f2 - f1)
    print(f3 * f1)
    print(f1 / f2)


if __name__ == ‘__main__‘:
    main()

五子棋

import pygame

EMPTY = 0
BLACK = 1
WHITE = 2

black_color = [0, 0, 0]
white_color = [255, 255, 255]


class RenjuBoard(object):

    def __init__(self):
        self._board = [[]] * 15
        self.reset()

    def reset(self):
        """重置棋盘"""
        for row in range(len(self._board)):
            self._board[row] = [EMPTY] * 15

    def move(self, row, col, is_black):
        if self._board[row][col] == EMPTY:
            self._board[row][col] = BLACK if is_black else WHITE
            return True
        return False

    def draw(self, screen):
        """
        画棋盘，天元，四点，画棋子
        :param screen:
        :return:
        """
        for i in range(1, 16):
            pygame.draw.line(screen, black_color, [40, i * 40], [600, i * 40], 1)  # 画行
            pygame.draw.line(screen, black_color, [i * 40, 40], [i * 40, 600], 1)  # 画列
        pygame.draw.rect(screen, black_color, [36, 36, 568, 568], 4)  # 画边框
        pygame.draw.circle(screen, black_color, [320, 320], 5, 0)  # 坐标，半径，0是实心，1是圆周的粗细
        pygame.draw.circle(screen, black_color, [160, 160], 5, 0)
        pygame.draw.circle(screen, black_color, [480, 480], 5, 0)
        pygame.draw.circle(screen, black_color, [160, 480], 5, 0)
        pygame.draw.circle(screen, black_color, [480, 160], 5, 0)
        for row in range(len(self._board)):
            for col in range(len(self._board[row])):
                if self._board[row][col] != EMPTY:  # 对于棋盘上的所有点，如果部位
                    ccolor = black_color if self._board[row][col] == BLACK else white_color
                    pos = [40 * (col + 1), 40 * (row + 1)]
                    pygame.draw.circle(screen, ccolor, pos, 18, 0)


def main():
    board = RenjuBoard()
    is_black = True
    pygame.init()
    pygame.display.set_caption(‘五子棋‘)
    screen = pygame.display.set_mode([640, 640])
    screen.fill([255, 255, 0])  # 红绿蓝三原色的值！
    board.draw(screen)
    pygame.display.flip()
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYUP:
                board.reset()
            elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                x, y = event.pos
                row = round((y - 40) / 40)
                col = round((x - 40) / 40)
                if board.move(row, col, is_black):
                    is_black = not is_black
                    screen.fill([255, 255, 0])
                    board.draw(screen)
                    pygame.display.flip()
    pygame.quit()


if __name__ == ‘__main__‘:
    main()

打球吃小球

from random import randint
import pygame


class Ball(object):

    def __init__(self, center, color, radius, sx, sy):
        self._center = center
        self._color = color
        self._radius = radius
        self._sx = sx
        self._sy = sy

    @property
    def center(self):
        return self._center

    @property
    def radius(self):
        return self._radius

    def move(self):
        """移动后的坐标"""
        x, y = self._center[0], self._center[1]
        x += self._sx
        y += self._sy
        self._center = (x, y)
        if (x + self._radius >= 800 and self._sx > 0) or (x - self._radius <= 0 and self._sx < 0):
            self._sx = -self._sx
        if (y + self._radius >= 600 and self._sy > 0) or (y - self._radius <= 0 and self._sy < 0):
            self._sy = - self._sy

    def eat(self, other):
        pass

    def draw(self, screen):
        """画一个圆"""
        pygame.draw.circle(screen, self._color, self._center,
                           self._radius, 0)


def refresh(screen, balls):
    bg_color = (242, 242, 242)
    screen.fill(bg_color)
    for ball in balls:
        ball.draw(screen)
    pygame.display.flip()


def random_color():
    red = randint(0, 255)
    green = randint(0, 255)
    blue = randint(0, 255)
    return red, green, blue


def main():
    pygame.init()
    balls = []
    screen = pygame.display.set_mode([800, 600])  # 窗口大小
    pygame.display.set_caption(‘大球吃小球‘)  # 标题
    clock = pygame.time.Clock()
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.MOUSEBUTTONDOWN and                     event.button == 1:
                # = event.pos
                color = random_color()
                radius = randint(10, 100)
                sx, sy = randint(-10, 10), randint(-10, 10)
                ball = Ball(event.pos, color, radius, sx, sy)
                balls.append(ball)
        refresh(screen, balls)
        clock.tick(20)
        for ball in balls:
            ball.move()
    pygame.quit()


if __name__ == ‘__main__‘:
    main()