【无标题】

XAX520_1314

于 2024-05-14 13:57:02 发布

阅读量776

点赞数 7

文章标签： python 爬虫开发语言

本文链接：https://blog.csdn.net/XAX520_1314/article/details/138852258

版权

# 1.编写一个学生类Student，定义3个属性name、age和id，分别表示学生的姓名、年龄和学号。
# 第一个学生的学号为1，以后每生成一个学生对象，学号增加1。初始化学生对象时，需要提供姓名和年龄。
# 每个学生对象生成以后需要调用自定义的info()方法输出姓名、年龄和学号。

class Student:
_student_id_counter = 1 # 定义一个类级别的静态变量用于存储当前学号

def __init__(self, name: str, age: int):
self.name = name
self.age = age
self.id = self._generate_next_id() # 初始化学号

@classmethod
def _generate_next_id(cls): #类方法
next_id = cls._student_id_counter
cls._student_id_counter += 1 # 每创建一个学生对象，学号增加1
return next_id

def info(self):
print(f"Name: {self.name}, Age: {self.age}, ID: {self.id}")

# 示例：创建两个学生对象并调用info()方法
student1 = Student("肖翱翔", 18)
student1.info()

student2 = Student("肖翱飞", 20)
student2.info()

print("人工智能")
print("第一组")
print("肖翱翔")

# 2. 创建类MyMath，计算圆的周长、面积和球的表面积、体积，结果保留两位小数。提示：要引入math包。例如，请输入半径：5
# 圆的周长：31.42
# 圆的面积：78.54
# 球的表面积：314.16
# 附加功能（可选）：非法数值判断
# 若输入的是非数字，则输出：请输入数字！
# 若输入的是负数，则输出：请输入正数！

import math

class MyMath:
    def __init__(self, radius):     #类的构造函数
        self.radius = radius

    def calculate_circle_circumference(self):
        return round(2 * math.pi * self.radius, 2)

    def calculate_circle_area(self):
        return round(math.pi * self.radius ** 2, 2)

    def calculate_sphere_surface_area(self):
        return round(4 * math.pi * self.radius ** 2, 2)

    def calculate_sphere_volume(self):
        return round((4/3) * math.pi * self.radius ** 3, 2)

# Input validation
radius_input = input("请输入半径：")

if not radius_input.isdigit():
    print("请输入数字！")
elif float(radius_input) < 0:
    print("请输入正数！")
else:
    radius = float(radius_input)
    math_obj = MyMath(radius)

    print(f"圆的周长：{math_obj.calculate_circle_circumference()}")
    print(f"圆的面积：{math_obj.calculate_circle_area()}")
    print(f"球的表面积：{math_obj.calculate_sphere_surface_area()}")
    print(f"球的体积：{math_obj.calculate_sphere_volume()}")
    print("人工智能")
    print("第一组")
    print("肖翱翔")

# 3. 实现一个名为“Rectangle”的表示矩形的类，该类包含两个实例属性width和height，分别表示矩形的宽和高，都是可读写的property，并且在写操作时检查是否为正值。
# 同时，还有一个名为area()的方法，是一个只读的property，该方法返回矩形的面积。

class Rectangle:
def __init__(self, width, height): #构造函数
self._width = width #实例属性
self._height = height #实例属性

#使用@property装饰器进行封装
@property
def width(self):
return self._width

@width.setter
def width(self, value):
if value > 0:
self._width = value
else:
print("宽度必须为正值！")

@property
def height(self):
return self._height

@height.setter
def height(self, value):
if value > 0:
self._height = value
else:
print("高度必须为正值！")

@property
def area(self):
return self._width * self._height

# 测试
rectangle = Rectangle(5, 10)
print(rectangle.width) # 输出: 5
print(rectangle.height) # 输出: 10
print(rectangle.area) # 输出: 50

rectangle.width = 8
rectangle.height = 12
print(rectangle.area) # 输出: 96

rectangle.width = -3 # 输出: 宽度必须为正值！
rectangle.height = -5 # 输出: 高度必须为正值！
print("人工智能")
print("第一组")
print("肖翱翔")

# 4.自定义类模拟三维向量及其运算。
# 包括向量的加法、减法以及向量与标量的乘法和除法，并查看向量长度。
# 例如， a=(x1,y1,z1), b=(x2,y2,z2)
# a+b=(x1+x2,y1+y2,z1+z2), a-b=(x1-x2,y1-y2,z1-z2)
# n=10, a*n=(x1*n,y1*n,z1*n), a/n=(x1/n,y1/n,z1/n)
# a.length=(x1**2+y1**2+z1**2)**0.5

import math

class Vector3D:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __add__(self, other):
        return Vector3D(self.x + other.x, self.y + other.y, self.z + other.z)

    def __sub__(self, other):
        return Vector3D(self.x - other.x, self.y - other.y, self.z - other.z)

    def __mul__(self, scalar):
        return Vector3D(self.x * scalar, self.y * scalar, self.z * scalar)

    def __truediv__(self, scalar):
        return Vector3D(self.x / scalar, self.y / scalar, self.z / scalar)

    @property
    def length(self):
        return math.sqrt(self.x**2 + self.y**2 + self.z**2)

# 测试
a = Vector3D(1, 2, 3)
b = Vector3D(4, 5, 6)

print(f"a + b = ({a.x + b.x}, {a.y + b.y}, {a.z + b.z})")
print(f"a - b = ({a.x - b.x}, {a.y - b.y}, {a.z - b.z})")
print(f"a * 10 = ({a.x * 10}, {a.y * 10}, {a.z * 10})")
print(f"a / 2 = ({a.x / 2}, {a.y / 2}, {a.z / 2})")
print(f"Length of a: {a.length}")
print(f"Length of b: {b.length}")
print("人工智能")
print("第一组")
print("肖翱翔")

# 5.设计一个摆放家具实例，要求：
# （1）房子(House) 有户型、总面积和家具名称列表（新房子没有任何的家具）；
# （2）家具(HouseItem)有名字和占地面积，其中席梦思(bed) 占地4平米、衣柜(chest)占地2平米、餐桌(table)占地1.5平米；
# （3）将以上三件家具添加到房子中；
# （4）打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表。

class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

class House:
    def __init__(self, house_type, total_area):
        self.house_type = house_type
        self.total_area = total_area
        self.furniture = []

    def add_furniture(self, item):
        if self.total_area >= item.area:
            self.furniture.append(item)
            self.total_area -= item.area
            print(f"{item.name} added to the house.")
        else:
            print(f"Not enough space to add {item.name} in the house.")

    def __str__(self):
        furniture_names = [item.name for item in self.furniture]
        return f"House Type: {self.house_type}, Total Area: {self.total_area} sqm, Remaining Area: {self.total_area} sqm, Furniture: {', '.join(furniture_names)}"

bed = HouseItem("Bed", 4)
chest = HouseItem("Chest", 2)
table = HouseItem("Table", 1.5)

my_house = House("2 Bedroom Apartment", 100)
my_house.add_furniture(bed)
my_house.add_furniture(chest)
my_house.add_furniture(table)

print(my_house)
print("人工智能")
print("第一组")
print("肖翱翔")

6. 继承 Python内置的字符串类str，根据给定整数（正数代表左移，负数代表右移）实现字符串的左右循环移动。

例如，a = MoveableStr("abcde")

print(a.move(3)) # 输出deabc

print(a.move(-3)) # 输出cdeab

class MoveableStr(str):
      def __new__(cls, value):
            # 注意：str.__new__ 负责创建新的字符串实例
            # 我们需要调用 super().__new__ 来确保正确创建
            return super().__new__(cls, value)
      def move(self, shift):
            # 确保 shift 是整数
            if not isinstance(shift, int):
                  raise ValueError("Shift must be an integer.")
                  # 计算实际移动的位数（取模长度确保循环）
            length = len(self)
            if length == 0:
                  return self  # 空字符串不移动
            # 计算实际移动的位数，并处理负数（右移）的情况
            shift %= length
            if shift < 0:
                  shift += length  # 将负数转换为正数，实现循环左移
            # 使用切片操作来生成移动后的字符串
            return self[-shift:] + self[:-shift]

      # 使用示例
a = MoveableStr("abcde")
print(a.move(-3))  # 输出deabc
print(a.move(3))  # 输出cdeab
print("人工智能")
print("第一组")
print("肖翱翔")

# 7. 定义类Dimension（包含x、y坐标），类Circle和 Rectangle继承了Dimension的成员变量x和y，并重写继承的方法area()。

import math

class Dimension:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        # 注意：Dimension类通常不会定义area方法，因为它不包含计算面积所需的信息

class Circle(Dimension):
    def __init__(self, x, y, radius):
        super().__init__(x, y)  # 调用父类的构造函数
        self.radius = radius
    def area(self):
        return math.pi * (self.radius ** 2)

class Rectangle(Dimension):
    def __init__(self, x, y, width, height):
        super().__init__(x, y)  # 调用父类的构造函数
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height

    # 使用示例
circle = Circle(0, 0, 5)
print(circle.area())  # 输出圆的面积
rectangle = Rectangle(0, 0, 10, 5)
print(rectangle.area())  # 输出矩形的面积
print("人工智能")
print("第一组")
print("肖翱翔")

# 8. 请定义类Point（一个点包含x、y坐标），通过重写相应的魔方方法，使其支持如下运算符操作：
# （1）p1+p2，两个点的x、y坐标分别相加，返回一个新的 Point对象；
# （2）p1-p2，两个点的x、y坐标分别相减,返回一个新的 Point对象；
# （3）p*n，用点的x、y坐标分别乘以数值n，返回一个新的Point对象；
# （4）p/n，用点的x、y坐标分别除以数值n，返回一个新的Point对象。
# # 测试代码
# if __name__ == '__main__':
# a,b=Point(4,5),Point(2,3)
# print(a+b) # 输出结果为'Point(6,8)'
# print(a-b) # 输出结果为'Point(2,2)'
# print(a*2) # 输出结果为'Point(8,10)'
# print(a/2) # 输出结果为'Point(2.0,2.5)'

class Point:

    def __init__(self, x, y):

        self.x = x

        self.y = y

    def __repr__(self):

        # 提供一个友好的表示形式，用于print函数

        return f'Point({self.x},{self.y})'

    def __add__(self, other):

        # 实现加法运算，两个点的x、y坐标分别相加

        if not isinstance(other, Point):
            raise TypeError("Unsupported operand types for +: 'Point' and '{}'".format(type(other).__name__))

        return Point(self.x + other.x, self.y + other.y)

    def __sub__(self, other):

        # 实现减法运算，两个点的x、y坐标分别相减

        if not isinstance(other, Point):
            raise TypeError("Unsupported operand types for -: 'Point' and '{}'".format(type(other).__name__))

        return Point(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):

        # 实现乘法运算，点的x、y坐标分别乘以数值n

        if not isinstance(scalar, (int, float, complex)):
            raise TypeError("Unsupported operand types for *: 'Point' and '{}'".format(type(scalar).__name__))

        return Point(self.x * scalar, self.y * scalar)

    def __truediv__(self, scalar):

        # 实现除法运算，点的x、y坐标分别除以数值n

        if not isinstance(scalar, (int, float, complex)) or scalar == 0:
            raise ValueError("Cannot divide by zero")

        return Point(self.x / scalar, self.y / scalar)

    # 测试代码


if __name__ == '__main__':
    a, b = Point(4, 5), Point(2, 3)

    print(a + b)  # 输出结果为'Point(6,8)'

    print(a - b)  # 输出结果为'Point(2,2)'

    print(a * 2)  # 输出结果为'Point(8,10)'

    print(a / 2)  # 输出结果为'Point(2.0,2.5)'

    print("人工智能")
    print("第一组")
    print("肖翱翔")

# 9. 创建SchoolMem类，该类中包含三个数据成员：姓名、性别、年龄；

# 创建Student类，继承自SchoolMem类，添加额外三个数据成员：
# 班级、学号和数量统计；创建Teacher类，继承自SchoolMem类，添加额外三个数据成员：
# 学院、工号和数量统计。要求给每个类适当添加属性、成员方法和特殊方法(如构造方法)，实现学生和教师信息的输出。
# 实现并测试这个类。(建议在父类和子类中使用同名函数以实现多态，如在SchoolMem类、Student类和Teacher类中分别实现printInfo方法输出对象的信息。)

class SchoolMem:
    count = 0  # 数量统计（类变量）

    def __init__(self, name, gender, age):
        self.name = name

        self.gender = gender

        self.age = age

        SchoolMem.count += 1  # 每当创建一个实例时，增加数量统计

    def printInfo(self):
        print(f"姓名: {self.name}, 性别: {self.gender}, 年龄: {self.age}")

    @staticmethod
    def getTotalMembers():
        return SchoolMem.count


class Student(SchoolMem):
    count = 0  # 学生数量统计（类变量）

    def __init__(self, name, gender, age, class_name, student_id):
        super().__init__(name, gender, age)  # 调用父类的构造方法

        self.class_name = class_name

        self.student_id = student_id

        Student.count += 1  # 每当创建一个学生实例时，增加学生数量统计

    def printInfo(self):
        print(f"学生信息:")

        super().printInfo()  # 调用父类的printInfo方法

        print(f"班级: {self.class_name}, 学号: {self.student_id}")

    @staticmethod
    def getTotalStudents():
        return Student.count


class Teacher(SchoolMem):
    count = 0  # 教师数量统计（类变量）

    def __init__(self, name, gender, age, department, teacher_id):
        super().__init__(name, gender, age)  # 调用父类的构造方法

        self.department = department

        self.teacher_id = teacher_id

        Teacher.count += 1  # 每当创建一个教师实例时，增加教师数量统计

    def printInfo(self):
        print(f"教师信息:")

        super().printInfo()  # 调用父类的printInfo方法

        print(f"学院: {self.department}, 工号: {self.teacher_id}")

    @staticmethod
    def getTotalTeachers():
        return Teacher.count

    # 测试代码


if __name__ == '__main__':
    # 创建学生和教师实例

    student1 = Student("张三", "男", 20, "人工智能", "2315015180")

    student2 = Student("李四", "女", 21, "计算机科学与技术", "2315015181")

    teacher1 = Teacher("王老师", "男", 35, "计算机与软件学院", "T001")

    teacher2 = Teacher("赵老师", "女", 30, "传媒学院", "T002")

    # 调用printInfo方法

    student1.printInfo()

    student2.printInfo()

    teacher1.printInfo()

    teacher2.printInfo()

    # 输出总数量

    print(f"总成员数: {SchoolMem.getTotalMembers()}")

    print(f"学生总数: {Student.getTotalStudents()}")

    print(f"教师总数: {Teacher.getTotalTeachers()}")
print("人工智能")
print("第一组")
print("肖翱翔")

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

from abc import ABC, abstractmethod


class Car(ABC):

    def __init__(self, car_type, speed):
        self.type = car_type

        self.speed = speed

    @abstractmethod
    def increased_energy(self):
        """
        子类应该实现此方法以定义如何增加能源
        """
        pass

class GasolineCar(Car):

    def __init__(self, car_type, speed):
        super().__init__(car_type, speed)

    def increased_energy(self):
        print(f"为{self.type}小汽车加油")

class ElectricCar(Car):

    def __init__(self, car_type, speed):
        super().__init__(car_type, speed)

    def increased_energy(self):
        print(f"为{self.type}电动汽车充电")

    # 示例用法


gas_car = GasolineCar("红旗", 120)

gas_car.increased_energy()  # 输出: 为红旗小汽车加油

elec_car = ElectricCar("迈巴赫", 200)

elec_car.increased_energy()  # 输出: 迈巴赫电动汽车充电

print("人工智能")
print("第一组")
print("肖翱翔")