python学习之面对对象程序设计作业

1.设计一个简单的购房商贷月供计算器类，按照以下公式计算总利息和每月还款金额：
总利息=贷款金额*利率
每月还款金额 = （贷款金额+总利息）/贷款年限
贷款年限不同利率也不同，这里规定只有如下表所示的3种年限、利率。

class daikuan:
    def __init__(self,num,year):
        self.num = num
        self.year = year

    def lilv(self):
        if self.year == 3:
            return 0.0603
        elif self.year == 5:
            return 0.0612
        elif self.year ==20:
            return 0.0639

    def yuegong(self):
        return (self.num + (self.num*self.lilv()))/(self.year*12)

num=int(input("请输入贷款金额："))
year=int(input("请输入贷款年限(输入年份)：1. 3年(36个月) 2. 5年(60个月) 3. 20年(240个月)"))
dk = daikuan(num,year)
print("月供为:", dk.yuegong())

2.设计Bird、fish类，都继承自Animal类，实现其方法print_info()，输出如下信息。Animal类中的print_info()输出年龄：“我今年XX岁了”， Bird、fish类继承和覆盖Animal类中的print_info()方法输出：“我是一只XXX, 我今年XX岁了”。

class Animal:
    def __init__(self,age):
        self.age = age
    def print_info(self):
        print(f'我今年{self.age}岁了!')

class bird(Animal):
    def __init__(self,age,type):
        self.type = type
        super().__init__(age)
    def print_info(self):
        print(f'我是一只{self.type}的鸟')
        super().print_info()
class fish(Animal):
    def __init__(self, age, type):
        self.type = type
        super().__init__(age)

    def print_info(self):
        print(f'我是一只{self.type}的鱼')
        super().print_info()

Bird = bird(4,"红色")
Fish = fish(2,"5斤重")
Bird.print_info()
Fish.print_info()

3.
绝地求生游戏
（1）定义玩家类Player
变量：name、blood（血量）、weapon（武器）
方法：装备武器、攻击
（2）定义武器类weapon
变量：weapon_type（武器类型）、lethal（杀伤力）
（3）攻击敌人
创建玩家和敌人对象并初始化属性
创建武器对象之后让玩家对象装备武器
玩家调用攻击方法攻击

class Player:
    def __init__(self,name,blood):
        self.name = name
        self.blood = blood
        self.weapon = None
        print(f'创建了名字为{self.name}的角色')
    def putonweapon(self,weapon):
        self.weapon = weapon
        print(f'{self.name}装备了伤害为{weapon.lethal}的{weapon.lethal}')
    def attack(self,target):
        target.blood = target.blood - self.weapon.lethal
        print(f'{self.name}使用{self.weapon.weapon_type}对{target.name}造成了{self.weapon.lethal}点伤害,{target.name}还剩{target.blood}点血')
class weapon():
    def __init__(self,weapon_type,lethal):
        self.weapon_type = weapon_type
        self.lethal = lethal

player = Player("Alita",100)
enemy = Player('Nova',100)
wuqi = weapon("encourge",10)
player.weapon = wuqi
player.attack(enemy)

4.定义一个学生类（Student），要求：
（1）初始化数据成员数据成员（Sno，Sname，Sage）；
（2）通过属性装饰器定义数据成员（Sno，Sname，Sage）；
（3）定义特殊方法__str(self),该方法返回：这样的字符串“我叫张三,学号是1101,年龄为33,是一名学生”，其中张三，1101，33，根据用户的输入来显示。”；
（4）通过继承定义一个研究生类（Gra_student），并增加数据成员研究方向（research）
（5)在Gra_student类中，定义特殊方法__str(self),该方法返回：我叫李四,学号是1102,年龄为35,是一名研究生，研究方向是complex network；
（6）调用学生类s=Student(‘zs’,‘1101’,23)，及类中的殊方法__str__(self)，修改学生年龄为33，再次调用__str__(self)；
（7）调用研究生类ga=Gra_student(‘李四’,‘1102’,35,‘complex network’)，调用__str__(self)。

class Student:
    def __init__(self,Sname,Sno,Sage):
        self._Sno = Sno
        self._Sname = Sname
        self._Sage = Sage
    @property
    def Sno(self):
        return self._Sno
    @Sno.setter
    def Sno(self,sno):
        self._Sno = sno
    @property
    def Sname(self):
        return self._Sname
    @Sname.setter
    def Sname(self, sname):
        self._Sname = sname
    @property
    def Sage(self):
        return self._Sage
    @Sage.setter
    def Sage(self, sage):
        self._Sage = sage
    def __str__(self):
        return (f'我叫{self._Sname},学号是{self._Sno},年龄为{self._Sage},是一名学生')
class Gra_student(Student):
    def __init__(self, Sname, Sno, Sage, research):
        super().__init__(Sno, Sname, Sage)
        self._research = research
    @property
    def reserach(self):
        return self._research
    def __str__(self):
        return (f'我叫{self._Sname},学号是{self._Sno},年龄为{self._Sage},是一名研究生，研究方向是{self._research}')

s = Student('zs','1101',23)
print(s)
s._Sage = 33
print(s)
g = Gra_student('李四','1102',35,'complex network')
print(g)

5.定义一个三维向量类，并定义相应的特殊方法实现两个该类对象之间的加、减运算（要 求支持运算符+、-），实现该类对象与标量的乘、除运算（要求支持运算符*、/），以及向 量长度的计算（要求使用属性实现）。

class Vector3:
    # 构造方法，初始化，定义向量坐标
    def __init__(self,x,y,z):
        self.__x = x
        self.__y = y
        self.__z = z

    # 与一个向量相加，对应分量相加，返回新向量
    def __add__(self, anotherPoint):
        x = self.__x + anotherPoint.__x
        y = self.__y + anotherPoint.__y
        z = self.__z + anotherPoint.__z
        return Vector3(x,y,z)

    # 减去另一个向量，对应分量相减，返回新向量
    def __sub__(self, anotherPoint):
        x = self.__x - anotherPoint.__x
        y = self.__y - anotherPoint.__y
        z = self.__z - anotherPoint.__z
        return Vector3(x, y, z)

    # 向量与一个数字相乘，各分量乘以同一个数字，返回新向量
    def __mul__(self, n):
        x, y, z = self.__x*n, self.__y*n, self.__z*n
        return Vector3(x,y,z)

    # 向量除以一个数字，各分量除以同一个数字，返回新向量
    def __truediv__(self, n):
        x, y, z = self.__x/n, self.__y/n, self.__z/n
        return Vector3(x, y, z)

    # 查看向量长度，所有分量平方和的平方根
    @property
    def length(self):
        return (self.__x**2 + self.__y**2 + self.__z**2)
    def __str__(self):
        return 'Vector3({},{},{})'.format(self.__x,self.__y,self.__z)

v1 = Vector3(1, 2, 3)
v2 = Vector3(3, 4, 5)
print(v1+v2)
print(v1-v2)
print(v1*3)
print(v2/2)
print(v1.length)
print(v2.length)