Python实验报告四 python基础试题练习
-
定义一个学校人员类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()