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

A-艺凡

已于 2022-05-04 19:25:53 修改

阅读量4.7k

点赞数 18

分类专栏： Python 文章标签： python 开发语言 pycharm

于 2022-05-02 21:48:40 首次发布

本文链接：https://blog.csdn.net/weixin_51717662/article/details/124547321

版权

Python 专栏收录该内容

5 篇文章 3 订阅

订阅专栏

定义一个学校人员类SchoolPerson，

其中属性：姓名name、性别sex、年龄age；

方法：设置人员的各个属性的set_info方法；

获取各属性值的get_info方法。

定义好类以后，再定义2个人员进行测试。
在第1个题的基础上添加两个方法：

其中，__init__()方法，完成属性的初始化；

__del__()方法，完成输出“__del__方法调用”这一句话（作用是用来销毁对象）。
创建类MyMath,计算圆的周长、面积和球的表面积、体积，结果保留两位小数。若输入的是非数字，则输出：请输入数字！提示：要引入math包。
自定义类模拟三维向量及其运算。包括向量的加法、减法以及向量与标量的乘法和除法，并使用@property查看向量长度。
设计一个摆放家具实例，要求：

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

（新房子没有任何的家具）

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

（3）将以上三件家具添加到房子中

（4）打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表
设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法和除法运算（要求重载__add__、__sub__、__mul__等方法）。
创建SchoolMem类，该类中包含三个数据成员：姓名、性别、年龄；创建Student类，继承自SchoolMem类，添加额外三个数据成员：班级、学号和数量统计；创建Teacher类，继承自SchoolMem类，添加额外三个数据成员：学院、工号和数量统计。要求给每个类适当添加属性、成员方法和特殊方法(如构造方法)，实现学生和教师信息的输出，实现并测试这个类。
设计一个车类，属性：车的类型、车的速度，分别再建立两个子类：小汽车类、电动汽车类去继承车类，为了实现汽车增加能源的方式，在父类中添加一个增加能源方法 increased_energy() ，通过汽车对象不同分别实现小汽车类加油、电动汽车充电的实现。

Python实验四报告

一．实验内容：

定义一个学校人员类SchoolPerson，

其中属性：姓名name、性别sex、年龄age；

方法：设置人员的各个属性的set_info方法；

获取各属性值的get_info方法。

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

实验过程：

定义一个SchoolPerson类。
分别写三个属性：name,sex,age.
定义一个set_info方法来设置人员的各个属性。
再定义一个get_info方法来获取输出人员的各个属性值。
编写两个人员s1,s2测试类。
向set_info方法内传入属性值。
再用get_info方法获取人员属性值输出。

实验结果：

实验小结：

要知道类定义的格式。并会在类中运用方法。在类中定义的属性不能随意更改。向类中传入属性值时由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__方法调用”这一句话（作用是用来销毁对象）。

实验过程：

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

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

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

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

6.调用__del__()方法。

7.调用get_info方法。

实验结果：

实验小结：

每当进行类的实例化时，初始化方法会自动被执行。当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包。

实验过程：

导入一个包，math.
定义一个MyMath类。
初始化类中属性。
定义周长，面积，表面积，体积方法。
从键盘录入半径r。
用if...else判断输入的是否为数字，如果是就定义一个对象类。分别调用各个方法，如果不是就输出：请输入数字。

实验结果：

实验小结：

本次实验主要是要导入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查看向量长度。

实验过程：

定义一个MyArray类，并初始化其中的属性。
分别增加向量的加法，减法，与标量的乘法和除法的方法。
在各个方法中进行运算并输出求得的新向量。
用@property将长度属性变为私有属性。
从键盘录入六个数值。
调用类中方法。

实验结果：

实验小结：

@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）打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

实验过程：

定义家具类HouseItem,并创建家具对象。
初始化类中的属性，使用__str__方法返回一个家具的描述。
定义一个房子类House，并创建house_type和area对象。
初始化类中属性，再定义属性-剩余面积的初始值等于总面积；属性-家具名称列表。
使用__str__()方法来返回一下房子的描述。
定义一个添加家具的方法add_item().
判断家具的面积，太大则无法增加，直接返回，符合则继续执行下列步骤。
将家具名称添加到列表中，计算剩余面积。
创建床对象bed。创建衣柜对象chest。创建餐桌对象table。
打印输出家具对象的信息。
创建房子对象，指定户型和面积。
将房子添加家具。
打印输出房子对象my_home.

实验结果：

实验小结：

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

代码：

# 设计一个摆放家具实例，要求：
#
# （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__等方法）。

实验过程：

定义一个三位向量类MyArry。
初始化类中的属性。
定义加法，减法，向量与标量的乘法，除法运算方法。

实验结果：

实验小结：

@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类，添加额外三个数据成员：学院、工号和数量统计。要求给每个类适当添加属性、成员方法和特殊方法(如构造方法)，实现学生和教师信息的输出，实现并测试这个类。

实验过程：

创建一个SchoolMen类，并初始化类里面的属性。
在SchoolMen类中定义两个方法Alter和PrintInfo。一个来输入属性值，一个来输出属性值。
创建学生类Student继承于SchoolMen类。
初始化里面的属性值。并用super()解决父类查询问题。
在Student类中定义两个方法Alter和PrintInfo。一个来输入属性值，一个来输出属性值。
创建学生类Teacher继承于SchoolMen类。
初始化里面的属性值并用super()解决父类查询问题。
在Teacher类中定义两个方法Alter和PrintInfo。一个来输入属性值，一个来输出属性值。
定义一个学生类对象a，向中传入值。，调用学生类中的方法输出值。
定义一个教师类对象b，向中传入值。，调用学生类中的方法输出值。

实验结果：

实验小结：

一个父类可由多个子类继承，在子类中可以用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.在类中定义一个增加能源的方法。

实验结果：

实验小结：

abc模块主要的功能：

某种情况下，判定某个对象的类型。如：isinstance(a,Sized).
强制子类必须实现某些方法，即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()

A-艺凡

关注

18
点赞
踩
74

收藏

觉得还不错? 一键收藏
5
评论
Python实验报告四 python基础试题练习

定义一个学校人员类SchoolPerson其中属性：姓名name、性别sex、年龄age；方法：设置人员的各个属性的set_info方法；获取各属性值的get_info方法。定义好类以后，再定义2个人员进行测试。在第1个题的基础上添加两个方法其中，__init__()方法，完成属性的初始化__del__()方法，完成输出“__del__方法调用”这一句话（作用是用来销毁对象）。自定义类模拟三维向量及其运算。包括向量的加法、减法以及向量与标量的乘法和除法，并使用@property查看向量长度。
复制链接

扫一扫