python面向对象综合练习

练习1：定义一个类来表示平面上的点，提供移动点和计算到另外一个点距离的方法。

class Point():
    #点的静态属性
    def __init__(self,x,y):
        self.x = x
        self.y = y
    # 移动到的点
    def move_to(self,x,y):
        self.x = x
        self.y = y
    # 移动了
    def move_by(self,dx,dy):
        self.x += dx
        self.y += dy

    def distance(self,other):
        lens=((self.x - other.x)**2 + (self.y - other.y)**2)**0.5
        return f'{lens:.2f}'

d1=Point(10,28)
d1.move_to(50,89)  # 表示移动到这个点（50,89）
d1.move_by(10,10)  # 表示在原坐标的基础上移动，移动后的点为（20,38）

练习2：在练习1的基础上，定义一个类来表示平面上的线段，提供长度属性和判断两条线段（对应的直线）是否平行的方法，重叠（共线）也算平行。

class Line():
    # start和end是练习一中的实例化对象
    def __init__(self,start,end):
        self.start = start
        self.end = end

    def length(self):
        # 返回练习一中的距离方法
        return self.start.distance(self.end)

    def relationship(self,other):
        # 给四个点
        sx1, sy1, ex1, ey1 = self.start.x, self.start.y, self.end.x, self.end.y
        sx2, sy2, ex2, ey2 = self.start.x, self.start.y, self.end.x, self.end.y

        # 斜率法判断两条线之间的关系，斜率不等则相交
        if (ey1-sy1)/(ex1-sx1) != (ey2-sy2)/(ex2-sx2):
            print('相交')
        else:
            print('平行')

p1=Point(2,3)
p2=Point(4,5)
p3=Point(8,9)
p4=Point(10,12)

print(p3.distance(p4))
line1=Line(p1,p2)
line2=Line(p3,p4)
line1.relationship(line2)

练习3：定义一个类实现倒计时的计时器（请参考手机上的计时器）。

import time
class Countdown():
    def __init__(self,hour,minute,second):
        self.hour = hour
        self.minute = minute
        self.second = second
    
    # 展示时间信息
    def show(self):
        return f'{self.hour:0>2d}:{self.minute:0>2d}:{self.second:0>2d}'

    # 退出终止方法
    def over(self):
        return self.hour != 0 or self.minute != 0 or self.second != 0

    # 走时间
    def run(self):
        if self.over():
            self.second -=1
            if self.second<0:
                self.second = 59
                self.minute -=1
                if self.minute <0:
                    self.minute = 59
                    self.hour -=1
# 调用部分
clock = Countdown(0,2,6)
print(clock.show())

while clock.over():
    time.sleep(1)          # 循环一次间隔一秒
    clock.run()            # 循环跑时间的方法
    print(clock.show())    # 跑一次展示一次

练习4：定义表示银行卡和ATM（自动柜员机）的类，要求ATM可以实现读卡、存钱、取钱、转账的功能。

 解题思路：

1. 定义一个card类：属性：卡号、截止日期、卡的类型
2. 定义第二个ATM类：

        属性：装入一个具备银行卡信息的数据库、声明一个卡的空容器、声明一个存放当前卡信息的容器

        方法（功能）：

• a.读卡：传入卡，通过卡号判断是否在数据库中；输入密码，密码加循环限制输入次数；如果成功  return  True  ，否则 return  False 。
• b.展示余额：如果卡的的信息容器不为空，则展示余额信息
• c.存钱：添加限制判断条件，余额累加
• d.取钱：添加限制判断条件，余额累减
• e.转账：传入转账卡卡号信息，及转账金额，本账户余额累减，转入账户余额累加
• f.拔卡：返回卡片初始容器，即退出

class AccountCard():
    '''创建卡片的静态属性'''
    def __init__(self,card_no,expiry_date,card_type='储蓄卡'):
        self.card_no=card_no
        self.card_type=card_type
        self.expiry_date=expiry_date
    # 格式化输出卡片信息
    def __repr__(self):
        return f'卡号：{self.card_no}  有效日期：{self.expiry_date}  卡类型：{self.card_type}'

class ATM():
    '''创建一个ATM机类，定义静态属性，传入一个账户信息数据库'''
    def __init__(self):
        self.accounts={
            '1122334455667788': {'password': '123321', 'balance': 12000.0 ,'valid':'True'},
            '1122334455667789': {'password': '123456', 'balance': 54321.0,'valid':'True'},
            '1122334455667790': {'password': '147258', 'balance': 0.0,'valid':'True'}
            }
        # 声明一个卡片容器属性、一个卡片信息容器属性
        self.current_card=None
        self.current_account=None

    def read_card(self,card):
        '''定义一个读取卡片信息的方法'''
        # 判断传入的卡片信息是否在数据库中
        if card.card_no in self.accounts:
            # 将数据库中对应的卡片信息赋值给信息容器
            self.current_account=self.accounts[card.card_no]
            # 密码输入次数限制
            for i in range(3):
                password = input('请输入密码：')
                if password==self.current_account['password']:
                    # 密码正确，则卡片读取成功，返回卡插入成功
                    self.current_card=card
                    return True
                else:
                    print('密码错误！')
            else:
                print('密码输入次数已经超过三次，已锁卡')
        else:
            print('账户不存在！')
            return False

    def show_blance(self):
        '''定义一个账户余额展示方法'''
        # 判断信息容器是否有信息
        if self.current_account:
            print(f"余额：{self.current_account['balance']}")

    def save_money(self,money):
        '''定义存钱的方法'''
        # 加入存钱限制条件
        if self.current_account and money >=100:
            self.current_account['balance'] += money
            print('存钱成功！')
            return True
        return False

    def get_money(self,money):
        '''定义一个取钱的方法'''
        # 添加限定条件
        if 100 <= money < self.current_account['balance'] and self.current_account:
            self.current_account['balance']-=money
            print('取钱成功！')
            return True
        return False

    def transfer(self,other_card_no,money):
        '''定义一个转账功能,传入转账卡号，金额'''
        # 添加限制条件
        if self.current_account and other_card_no in self.accounts:
            other_account=self.accounts[other_card_no]
            if money < self.current_account['balance']:
                self.current_account['balance'] -= money
                other_account['balance'] += money
                print('转账成功！')
                return True
            else:
                print('转账金额超限！')
            return False
        else:
            print('无效账户名')
        return False

    def move_card(self):
        '''拔卡'''
        self.accounts=None
        self.current_account=None

if __name__ == '__main__':
    # 准备两张卡片的信息
    card1=AccountCard('1122334455667788','2050-05-11','信用卡')
    card2=AccountCard('1122334455667789','2070-08-29')

    a=ATM()
    # 读取卡片信息
    a.read_card(card1)
    a.show_blance()
    # 存钱并查看
    a.save_money(5000)
    a.show_blance()
    #取钱并查看
    a.get_money(8000)
    a.show_blance()
    
    # 展示转账后卡2的信息
    a.transfer('1122334455667789',6666)
    a.read_card(card2)
    a.show_blance()

运行结果：

 

练习5：某公司有三种类型的员工，分别是部门经理、程序员和销售员。

其中，部门经理每月固定月薪15000元；

程序员计时支付月薪，每小时200元；

销售员按照1800元底薪加上销售额5%的提成支付月薪。

需求：设计一个工资计算系统，录入员工信息，计算员工的月薪。

from abc import ABCMeta,abstractmethod

class Employee(metaclass=ABCMeta):  # 抽象类不能实例化，但是子类可以继承
    '''继承抽象类'''
    def __init__(self,name):
        self.name=name
    # 将这个方法变成抽象方法，对象不能直接调用，但是子类可以重写这个方法
    @abstractmethod
    def give_salary(self):
        pass

class Magnaer(Employee):
    '''创建一个部门经理类'''
    def give_salary(self):
        return 15000.00

class Programmer(Employee):
    '''创建一个程序员类，添加一个工作时间属性'''
    def __init__(self,name,work_hour=0):
        super(Programmer, self).__init__(name)
        self.work_hour=work_hour

    def give_salary(self):
        return self.work_hour*200

class SalesMan(Employee):
    '''创建一个销售员类，添加一个销售额属性'''
    def __init__(self,name,sales=0):
        super(SalesMan, self).__init__(name)
        self.sales=sales

    def give_salary(self):
        return self.sales*0.05+1800

if __name__ == '__main__':
    emps = [Magnaer('曹操'),Programmer('诸葛亮'),Programmer('周瑜'), Programmer('关羽'),SalesMan('大乔'), SalesMan('小乔')]
    for emp in emps:
        if isinstance(emp,Programmer):
            emp.work_hour=float(input(f'请输入{emp.name}工作时长：'))
        elif isinstance(emp,SalesMan):
            emp.sales=float(input(f'请输入{emp.name}的销售额：'))
        print(f'{emp.name}的本月月薪为￥{emp.give_salary()} ')

运行结果如下：