Python实验报告四 python基础试题练习

  1. 定义一个学校人员类SchoolPerson,

    其中属性:姓名name、性别sex、年龄age;

            方法:设置人员的各个属性的set_info方法;

                      获取各属性值的get_info方法。  

    定义好类以后,再定义2个人员进行测试。

  2.  在第1个题的基础上添加两个方法:

    其中,__init__()方法,完成属性的初始化;

              __del__()方法,完成输出“__del__方法调用”这一句话(作用是用来销毁对象)。

  3. 创建类MyMath,计算圆的周长、面积和球的表面积、体积,结果保留两位小数。若输入的是非数字,则输出:请输入数字!提示:要引入math包。

  4. 自定义类模拟三维向量及其运算。包括向量的加法、减法以及向量与标量的乘法和除法,并使用@property查看向量长度。

  5. 设计一个摆放家具实例,要求:

    (1)房子(House) 有户型、总面积和家具名称列表

          (新房子没有任何的家具)

    (2)家具(HouseItem)有 名字和占地面积,其中席梦思(bed) 占地 4 平米、衣柜(chest) 占地 2 平米、餐桌(table) 占地 1.5 平米

    (3)将以上三件家具添加到房子中

    (4)打印房子时,要求输出:户型、总面积、剩余面积、家具名称列表

  6. 设计一个三维向量类,并实现向量的加法、减法以及向量与标量的乘法和除法运算(要求重载__add__、__sub__、__mul__等方法)。

  7. 创建SchoolMem类,该类中包含三个数据成员:姓名、性别、年龄;创建Student类,继承自SchoolMem类,添加额外三个数据成员:班级、学号和数量统计;创建Teacher类,继承自SchoolMem类,添加额外三个数据成员:学院、工号和数量统计。要求给每个类适当添加属性、成员方法和特殊方法(如构造方法),实现学生和教师信息的输出,实现并测试这个类。

  8. 设计一个车类,属性:车的类型、车的速度,分别再建立两个子类:小汽车类、电动汽车类去继承车类,为了实现汽车增加能源的方式,在父类中添加 一个增加能源方法 increased_energy() ,通过汽车对象不同分别实现小汽车类加 油、电动汽车充电的实现。

Python实验四报告

一.实验内容:

定义一个学校人员类SchoolPerson,

其中属性:姓名name、性别sex、年龄age;

        方法:设置人员的各个属性的set_info方法;

                  获取各属性值的get_info方法。  

定义好类以后,再定义2个人员进行测试。

  • 实验过程:
  1. 定义一个SchoolPerson类。
  2. 分别写三个属性:name,sex,age.
  3. 定义一个set_info方法来设置人员的各个属性。
  4. 再定义一个get_info方法来获取输出人员的各个属性值。
  5. 编写两个人员s1,s2测试类。
  6. 向set_info方法内传入属性值。
  7. 再用get_info方法获取人员属性值输出。

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第1张图片

  • 实验小结:

要知道类定义的格式。并会在类中运用方法。在类中定义的属性不能随意更改。向类中传入属性值时由set_info方法接受到类中,并由get_info方法获取传输数据。

代码:

# 定义一个学校人员类SchoolPerson,
#
# 其中属性:姓名name、性别sex、年龄age;
#
#         方法:设置人员的各个属性的set_info方法;
#
#                   获取各属性值的get_info方法。
#
# 定义好类以后,再定义2个人员进行测试。

class SchoolPerson:
    name: ''
    sex: ''
    age: ''

    def set_info(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def get_info(self):
        print(self.name, self.sex, self.age)


s1 = SchoolPerson()
s1.set_info('zhang', '男', 19)
s1.get_info()
s2 = SchoolPerson()
s2.set_info('lisi', '女', 18)
s2.get_info()

  • 实验内容:

在第1个题的基础上添加两个方法:

其中,__init__()方法,完成属性的初始化;

          __del__()方法,完成输出“__del__方法调用”这一句话(作用是用来销毁对象)。

  • 实验过程:
  1. 在第一个实验的基础上加两个方法。
  2. __init__()方法将类中的各个属性初始化。每当进行类的实例化时,初始化方法会自动被执行。

3.定义  __del__()方法,完成输出“__del__方法调用”这一句话(作用是用来销毁对象)。

4.从键盘中分别录入各个属性值。

5.将各个属性传入定义为s1的类中。

6.调用__del__()方法

7.调用get_info方法。

Python实验报告四 python基础试题练习_第2张图片

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第3张图片

  • 实验小结:

每当进行类的实例化时,初始化方法会自动被执行。当get_info方法被调用后,__del__()方法便会直接调用出来销毁这个对象。

代码:

#  在第1个题的基础上添加两个方法:
#
# 其中,__init__()方法,完成属性的初始化;
#
#           __del__()方法,完成输出“__del__方法调用”这一句话(作用是用来销毁对象)。
class SchoolPerson:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def __del__(self):
        print("__del__方法调用")

    def set_info(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def get_info(self):
        print(self.name, self.sex, self.age)


name1 = input('请输入姓名:')
sex1 = input('请输入性别:')
age1 = input('请输入年龄:')
s1 = SchoolPerson(name1, sex1, age1)
s1.__del__()
s1.get_info()

        

  • 实验内容:

创建类MyMath,计算圆的周长、面积和球的表面积、体积,结果保留两位小数。若输入的是非数字,则输出:请输入数字!提示:要引入math包。

  • 实验过程:
  1. 导入一个包,math.
  2. 定义一个MyMath类。
  3. 初始化类中属性。
  4. 定义周长,面积,表面积,体积方法。
  5. 从键盘录入半径r。
  6. 用if...else判断输入的是否为数字,如果是就定义一个对象类。分别调用各个方法,如果不是就输出:请输入数字。
  7. Python实验报告四 python基础试题练习_第4张图片

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第5张图片

  • 实验小结:

本次实验主要是要导入math包。这是实验成功的首要因素。接着就是定义各个方法,在方法里面写算法,输出计算内容。

代码:

# 创建类MyMath,计算圆的周长、面积和球的表面积、体积,结果保留两位小数。若输入的是非数字,则输出:请输入数字!提示:要引入math包。

import math
class MyMath:
    def __init__(self, r):
        self.r = r

    def perimeter(self):
        print('圆的周长 = {:.2f}'.format(2 * math.pi * r))  # format是字符串的一个方法,用于格式化字符串。

    def area(self):
        print('圆的面积 = {:.2f}'.format(math.pi * math.pow(r, 2)))

    def surface(self):
        print('球的表面积 = {:.2f}'.format(4 * math.pi * math.pow(r, 2)))

    def volume(self):
        print('球的体积 = {:.2f}'.format(4 / 3 * math.pi * math.pow(r, 3)))
r = input('请输入半径(整数):')

if r.isdigit():
    r = int(r)
    p1 = MyMath(r)
    p1.perimeter()
    p1.area()
    p1.surface()
    p1.volume()
else:
    print('请输入数字!')

  • 实验内容:

自定义类模拟三维向量及其运算。包括向量的加法、减法以及向量与标量的乘法和除法,并使用@property查看向量长度。

  • 实验过程:
  1. 定义一个MyArray类,并初始化其中的属性。
  2. 分别增加向量的加法,减法,与标量的乘法和除法的方法。
  3. 在各个方法中进行运算并输出求得的新向量。
  4. 用@property将长度属性变为私有属性。
  5. 从键盘录入六个数值。
  6. 调用类中方法。
  7. Python实验报告四 python基础试题练习_第6张图片

 Python实验报告四 python基础试题练习_第7张图片

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第8张图片

  • 实验小结:

@propoerty装饰器主要目的是将方法变为私有属性,防止对其修改

代码:

# 自定义类模拟三维向量及其运算。包括向量的加法、减法以及向量与标量的乘法和除法,并使用@property查看向量长度。

class MyArray:
    def __init__(self, x, y, z):
        self.__x = x
        self.__y = y
        self.__z = z

    def add(self, a):
        x = self.__x + a.__x
        y = self.__y + a.__y
        z = self.__z + a.__z
        print("和=({},{},{})".format(x, y, z))

    def sub(self, a):
        x = self.__x - a.__x
        y = self.__y - a.__y
        z = self.__z - a.__z
        print("差=({},{},{})".format(x, y, z))

    def mul(self, a):
        x = self.__x * a
        y = self.__y * a
        z = self.__z * a
        print("乘积=({},{},{})".format(x, y, z))

    def div(self, a):
        x = self.__x / a
        y = self.__y / a
        z = self.__z / a
        print("商=({},{},{})".format(x, y, z))

    @property
    def length(self):
        return round(pow(pow(self.__x, 2) + pow(self.__y, 2) + pow(self.__z, 2), 0.5), 3)


list = input("请输入六个数:").split()
print('N1:', list[0], list[1], list[2])
print('N2:', list[3], list[4], list[5])
n1 = MyArray(int(list[0]), int(list[1]), int(list[2]))
n2 = MyArray(int(list[3]), int(list[4]), int(list[5]))
n1.add(n2)
n1.sub(n2)
n1.mul(2)
n1.div(2)
print(n1.length)

  • 实验内容:

设计一个摆放家具实例,要求:

(1)房子(House) 有户型、总面积和家具名称列表

      (新房子没有任何的家具)

(2)家具(HouseItem)有 名字和占地面积,其中席梦思(bed) 占地 4 平米、衣柜(chest) 占地 2 平米、餐桌(table) 占地 1.5 平米

(3)将以上三件家具添加到房子中

(4)打印房子时,要求输出:户型、总面积、剩余面积、家具名称列表

  • 实验过程:
  1. 定义家具类HouseItem,并创建家具对象。
  2. 初始化类中的属性,使用__str__方法返回一个家具的描述。
  3. 定义一个房子类House,并创建house_type和area对象。
  4. 初始化类中属性,再定义属性-剩余面积的初始值等于总面积;属性-家具名称列表。
  5. 使用__str__()方法来返回一下房子的描述。
  6. 定义一个添加家具的方法add_item().
  7. 判断家具的面积,太大则无法增加,直接返回,符合则继续执行下列步骤。
  8. 将家具名称添加到列表中,计算剩余面积。
  9. 创建床对象bed。创建衣柜对象chest。创建餐桌对象table。
  10. 打印输出家具对象的信息。
  11. 创建房子对象,指定户型和面积。
  12. 将房子添加家具。
  13. 打印输出房子对象my_home.
  14. Python实验报告四 python基础试题练习_第9张图片
  15. Python实验报告四 python基础试题练习_第10张图片

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第11张图片

  • 实验小结:

实验要理清思路。主要分为两个类,家具类和房子类,将定义好的家具放到房子中并看是否合适,并计算出房子的剩余面积。

代码:

# 设计一个摆放家具实例,要求:
#
# (1)房子(House) 有户型、总面积和家具名称列表
#
#       (新房子没有任何的家具)
#
# (2)家具(HouseItem)有 名字和占地面积,其中席梦思(bed) 占地 4 平米、衣柜(chest) 占地 2 平米、餐桌(table) 占地 1.5 平米
#
# (3)将以上三件家具添加到房子中
#
# (4)打印房子时,要求输出:户型、总面积、剩余面积、家具名称列表
# 定义家具类HouseItem,并创建家具对象
class HouseItem:
    # 在初始化方法中使用self 来定义两个属性
    def __init__(self, name, area):
        self.name = name
        self.area = area

    # 使用__str__方法来返回一个家具的描述
    def __str__(self):
        # %s 来存放家具的名称
        # (self.name, self.area)是一个元组
        return "[%s] 占地 %.2f" % (self.name, self.area)


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area

        # 属性-剩余面积的初始值等于总面积
        self.free_area = area

        # 属性-家具名称列表,家具列表的初始值只是一个空列表
        self.item_list = []

        # 初始化方法准备完成,一共定义了4个属性
        # 这四个属性中,house_type和area 是通过形参传递的,另外两个属性的属性值是直接在初始化方法内部直接指定的

    # 使用__str__方法来返回一下房子的描述
    def __str__(self):
        # \n 输出完户型之后来一个换行
        # 格式字符串完成后, 再在后面跟上元组
        # python 能够自动的将一对括号内部的代码链接在一起
        return ("户型: %s\n总面积:%.2f[剩余面积: %.2f]\n家具: %s"
                % (self.house_type, self.area,
                   self.free_area, self.item_list))

    # 定义一个添加家具的方法
    def add_item(self, item):
        print("要添加 %s" % item)
        # 1. 判断家具的面积
        if item.area > self.free_area:
            print("%s 的面积太大了,无法添加" % item.name)

            # 无法添加, 就不用执行下方的代码, 就可以使用 return 关键字直接返回
            # return 这个关键字可以返回一个结果, 也可以不返回结果
            return

        # 2. 将家具的名称添加到列表中, 追加内容应该调用append方法
        self.item_list.append(item.name)

        # 3. 计算剩余面积,每添加一个家具就要让剩余面积减去这个家具的面积
        self.free_area -= item.area


# 在主程序中来完成创建家具的工作
# 1.创建家具

# 创建床对象 bed
bed = HouseItem("席梦思", 4)
# 创建衣柜对象 chest
chest = HouseItem("衣柜", 2)
# 创建餐桌对象 table
table = HouseItem("餐桌", 1.5)

# 打印家具对象的信息
print(bed)
print(chest)
print(table)

# 2. 创建房子对象,并指定户型和总面积
my_home = House("两室一厅", 60)

# 让房子这个对象my_home调用添家具的方法, 把家具都添加到新房子中,
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

  • 实验内容:

设计一个三维向量类,并实现向量的加法、减法以及向量与标量的乘法和除法运算(要求重载__add__、__sub__、__mul__等方法)。

  • 实验过程:
  1. 定义一个三位向量类MyArry。
  2. 初始化类中的属性。
  3. 定义加法,减法,向量与标量的乘法,除法运算方法。

Python实验报告四 python基础试题练习_第12张图片

 Python实验报告四 python基础试题练习_第13张图片

  • 实验结果:

​​​​​​​​​​​​​​Python实验报告四 python基础试题练习_第14张图片

  • 实验小结:

@propoerty装饰器主要目的是将方法变为私有属性,防止对其修改

代码:

# 设计一个三维向量类,并实现向量的加法、减法以及向量与标量的乘法和除法运算(要求重载__add__、__sub__、__mul__等方法)。
class MyArray:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __add__(self, a):
        x = self.x + a.x
        y = self.y + a.y
        z = self.z + a.z
        print("和=({},{},{})".format(x, y, z))

    def __sub__(self, a):
        x = self.x - a.x
        y = self.y - a.y
        z = self.z - a.z
        print("差=({},{},{})".format(x, y, z))

    def __mul__(self, a):
        x = self.x * a
        y = self.y * a
        z = self.z * a
        print("乘积=({},{},{})".format(x, y, z))

    def __truediv__(self, a):
        x = self.x / a
        y = self.y / a
        z = self.z / a
        print("商=({},{},{})".format(x, y, z))

    def length(self):
        a = pow(pow(self.x, 2) + pow(self.y, 2) + pow(self.z, 2), 0.5)
        print("长度为:{}".format(round(a, 3)))


# a = eval(input("请输入a:"))
# b = eval(input("请输入b:"))
# c = eval(input("请输入c:"))
# d = eval(input("请输入d:"))
# e = eval(input("请输入e:"))
# f = eval(input("请输入f:"))
# g = eval(input("请输入g:"))
a, b, c, d, e, f, g = eval(input('请输入值,用逗号隔开:'))

print('N1:', (a, b, c))
print('N2:', (d, e, f))
n1 = MyArray(a, b, c)
n2 = MyArray(d, e, f)
n1.__add__(n2)
n1.__sub__(n2)
n1.__mul__(2)
n1.__truediv__(2)
n1.length()

  • 实验内容:

创建SchoolMem类,该类中包含三个数据成员:姓名、性别、年龄;创建Student类,继承自SchoolMem类,添加额外三个数据成员:班级、学号和数量统计;创建Teacher类,继承自SchoolMem类,添加额外三个数据成员:学院、工号和数量统计。要求给每个类适当添加属性、成员方法和特殊方法(如构造方法),实现学生和教师信息的输出,实现并测试这个类。

  • 实验过程:
  1. 创建一个SchoolMen类,并初始化类里面的属性。
  2. 在SchoolMen类中定义两个方法Alter和PrintInfo。一个来输入属性值,一个来输出属性值。
  3. 创建学生类Student继承于SchoolMen类。
  4. 初始化里面的属性值。并用super()解决父类查询问题。
  5. 在Student类中定义两个方法Alter和PrintInfo。一个来输入属性值,一个来输出属性值。
  6. 创建学生类Teacher继承于SchoolMen类。
  7. 初始化里面的属性值并用super()解决父类查询问题。
  8. 在Teacher类中定义两个方法Alter和PrintInfo。一个来输入属性值,一个来输出属性值。
  9. 定义一个学生类对象a,向中传入值。,调用学生类中的方法输出值。
  10. 定义一个教师类对象b,向中传入值。,调用学生类中的方法输出值。

Python实验报告四 python基础试题练习_第15张图片

 Python实验报告四 python基础试题练习_第16张图片

 Python实验报告四 python基础试题练习_第17张图片

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第18张图片

  • 实验小结:

一个父类可由多个子类继承,在子类中可以用super()解决父类查询问题。

代码:

# 创建SchoolMem类,该类中包含三个数据成员:姓名、性别、年龄;创建Student类,继承自SchoolMem类,
# 添加额外三个数据成员:班级、学号和数量统计;创建Teacher类,继承自SchoolMem类,添加额外三个数据成员:
# 学院、工号和数量统计。要求给每个类适当添加属性、成员方法和特殊方法(如构造方法),实现学生和教师信息的输出,实现并测试这个类。
class SchoolMem:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def Alter(self):
        self.name = input('姓名')
        self.sex = input('性别')
        self.age = input('年龄')

    def PrintInfo(self):
        print(self.name)
        print(self.sex)
        print(self.age)


class Student(SchoolMem):
    total = 0

    def __init__(self, name, sex, age, cno, sno):
        # super()解决父类查询问题。
        super().__init__(name, sex, age)
        self.cno = cno
        self.sno = sno
        Student.total += 1

    def Alter(self):
        self.cno = input('输入学生所属班级:')
        self.sno = input('输入学生学号:')

    def PrintInfo(self):
        super(Student, self).PrintInfo()
        print(self.cno)
        print(self.sno)


class Teacher(SchoolMem):
    total = 0

    def __init__(self, name, sex, age, cono, jno):
        super().__init__(name, sex, age)
        self.cono = cono
        self.jno = jno
        Teacher.total += 1

    def Alter(self):
        self.cono = input('输入老师所属学院:')
        self.jno = input('输入老师工号:')

    def PrintInfo(self):
        super(Teacher, self).PrintInfo()
        print(self.cono)
        print(self.jno)


a = Student('张三', '男', '18', 5, 1902073564)
a.PrintInfo()
b = Teacher('李四', '男', '30', 2, 1351332)
b.PrintInfo()

  • 实验内容:

设计一个车类,属性:车的类型、车的速度,分别再建立两个子类:小汽车类、电动汽车类去继承车类,为了实现汽车增加能源的方式,在父类中添加 一个增加能源方法 increased_energy() ,通过汽车对象不同分别实现小汽车类加 油、电动汽车充电的实现。

  • 实验过程:

1.导入abc模块用来定义和使用抽象基类进行API检查。

2.创建一个车类,指定metaclass属性将类设置为抽象类。(抽象类本身只是用来约束子类的,不能被实例化)。

3.初始化车类中的属性。

4.@abstractmethod该装饰器限制子类必须定义有一个名为增加能源的方法。

5.创建车的子类,小汽车类,继承于车类,并初始化其中的属性。

6.在类中定义一个增加能源的方法。

7.创建车的子类,电动汽车类,继承于车类,并初始化其中的属性。

8.在类中定义一个增加能源的方法。

Python实验报告四 python基础试题练习_第19张图片

Python实验报告四 python基础试题练习_第20张图片

  • 实验结果:

​​​​​​​Python实验报告四 python基础试题练习_第21张图片

  • 实验小结:

abc模块主要的功能:

  1. 某种情况下,判定某个对象的类型。如:isinstance(a,Sized).
  2. 强制子类必须实现某些方法,即ABC类的派生类。

代码:

# 设计一个车类,属性:车的类型、车的速度,分别再建立两个子类:小汽车类、
# 电动汽车类去继承车类,为了实现汽车增加能源的方式,在父类中添加 一个增加能源方法 increased_energy() ,
# 通过汽车对象不同分别实现小汽车类加 油、电动汽车充电的实现。

# 在代码中定义和使用抽象基类进行API检查。
from abc import ABCMeta, abstractmethod




class vehicle(metaclass=ABCMeta):  # 车类

    def __init__(self, mold, speed):
        self.mold = mold

        self.speed = speed

    @abstractmethod
    def increased_energy(self):
        pass


class car(vehicle):  # 车的子类,小汽车类,继承父类的构造方法

    def __init__(self, mold, speed):
        vehicle.__init__(self, mold, speed)

    def increased_energy(self):
        print(self.mold + '需要加油,能达到速度', self.speed)


class bus(vehicle):  # 车的子类,电动汽车类,继承父类的构建方法

    def __init__(self, mold, speed):
        vehicle.__init__(self, mold, speed)

    def increased_energy(self):
        print(self.mold + '需要加油,能达到速度', self.speed)


car1 = car('小汽车', 120)

car1.increased_energy()

bus01 = car('公共汽车', 80)

bus01.increased_energy()

你可能感兴趣的:(Python,python,开发语言,pycharm)