25级数应四班第七次实验

2025010142 杨旭洁
用类组织晚会

# 晚会类
class Party:
    def __init__(self, name):
        self.name = name
        self.programs = []

    # 添加：节目 + 表演者
    def add(self, show, person):
        self.programs.append((show, person))

    # 展示节目单
    def show(self):
        print(f"【{self.name}】")
        for i, (s, p) in enumerate(self.programs, 1):
            print(f"{i}. {s} —— 表演者：{p}")

# 使用
party = Party("班级晚会")
party.add("唱歌", "张三")
party.add("跳舞", "李四")
party.add("小品", "王五")

party.show()

 

 2025010146 顾芳菲

计算形状为三角形，圆形，正方形组成房子的面积

import turtle
import math

# 图形基类
class Shape:
    def area(self):
        pass

# 三角形（屋顶）
class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def area(self):
        return 0.5 * self.base * self.height

# 正方形（墙体）
class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

# 圆形（窗户）
class Circle(Shape):
    PI = math.pi
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return self.PI * self.radius ** 2

# 房子类：绘图 + 面积计算
class House:
    def __init__(self, tri_base, tri_h, squ_side, cir_r):
        self.roof = Triangle(tri_base, tri_h)
        self.wall = Square(squ_side)
        self.window = Circle(cir_r)
        self.t = turtle.Turtle()
        self.t.speed(2)

    # 绘制整套房子
    def draw(self):
        t = self.t
        side = self.wall.side
        tri_base = self.roof.base
        tri_h = self.roof.height
        r = self.window.radius

        # 1. 画正方形墙体
        t.penup()
        t.goto(-side/2, -side/2)
        t.pendown()
        for _ in range(4):
            t.forward(side)
            t.left(90)

        # 2. 画三角形屋顶
        t.penup()
        t.goto(-tri_base/2, side/2)
        t.pendown()
        t.goto(0, side/2 + tri_h)
        t.goto(tri_base/2, side/2)
        t.goto(-tri_base/2, side/2)

        # 3. 画圆形窗户（正方形内部）
        t.penup()
        t.goto(0, 0 - r)
        t.pendown()
        t.circle(r)

        t.hideturtle()

    # 计算总面积（减去窗户）
    def get_total_area(self):
        return self.roof.area() + self.wall.area() - self.window.area()

# 主程序运行
if __name__ == "__main__":
    # 参数：三角形底、三角形高、正方形边长、圆半径
    house = House(tri_base=200, tri_h=80, squ_side=200, cir_r=40)
    house.draw()
    area = house.get_total_area()
    print(f"房子总面积（扣除圆形窗户）：{area:.2f}")
    turtle.done()

 

 

 

2025010151 侯益波

import matplotlib.pyplot as plt

# 模拟爬取到的音乐数据：(音乐类型, 歌曲总数)
music_data = [
    ("流行", 128600), ("摇滚", 45200), ("古风", 37900),
    ("电子", 29100), ("民谣", 35600), ("说唱", 41300),
    ("纯音乐", 26800), ("R&B", 22500), ("动漫", 19700)
]
types = [x[0] for x in music_data]
nums = [x[1] for x in music_data]

# 绘图
plt.rcParams["font.sans-serif"] = ["SimHei"]
plt.figure(figsize=(10, 6))
plt.bar(types, nums, color=["#f56c6c", "#67c23a", "#409eff", "#e6a23c", "#9b59b6"])
plt.title("各类音乐歌曲总数统计", fontsize=15)
plt.xlabel("音乐分类")
plt.ylabel("歌曲数量")
plt.xticks(rotation=30)
# 标注数字
for i, v in enumerate(nums):
    plt.text(i, v + 1000, str(v), ha="center")
plt.grid(axis="y", alpha=0.3)
plt.show()

2025010153范鹏展
爬取安康市房产数据

import requests
from bs4 import BeautifulSoup
import pandas as pd
import time

# 目标网址
URL = "https://www.akzfc.cn/fangchanxinxichaxun/"

# 请求头，模拟浏览器访问
HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Accept-Language": "zh-CN,zh;q=0.9"
}


def get_page_soup(url, retry=3):
    """获取网页的BeautifulSoup对象，失败自动重试"""
    for i in range(retry):
        try:
            res = requests.get(url, headers=HEADERS, timeout=15)
            res.raise_for_status()
            res.encoding = "utf-8"
            time.sleep(1)
            return BeautifulSoup(res.text, "html.parser")
        except Exception as e:
            print(f"请求失败：{e}")
            time.sleep(2)
    print("页面请求失败")
    return None


def parse_tables(soup):
    """解析页面中所有表格，表头列数和数据列数自动对齐，工作表名安全处理"""
    tables_data = []
    all_tables = soup.find_all("table")
    print(f"找到 {len(all_tables)} 个表格")

    # 表头定义（按顺序对应网站上的表格）
    custom_headers = [
        ["证号", "项目名称", "项目地址", "开发企业", "可销售总套数", "可销售总面积(㎡)"],
        ["统计周期", "套数", "面积(㎡)", "住宅套数", "住宅面积(㎡)", "商业套数", "商业面积(㎡)", "其他套数",
         "其他面积(㎡)"],
        ["统计周期", "类型", "总计", "住宅", "商业", "其他"]
    ]
    # 工作表名，和表格一一对应
    sheet_names = ["预售许可公示", "上市行情", "成交行情"]

    for idx, table in enumerate(all_tables):
        # 提取表格数据行
        rows = []
        for tr in table.find_all("tr")[1:]:
            td_list = [td.get_text(strip=True) for td in tr.find_all("td")]
            if td_list:
                rows.append(td_list)

        if rows:
            # 动态匹配表头长度，和数据列数保持一致
            data_cols = len(rows[0])
            if idx < len(custom_headers):
                headers = custom_headers[idx][:data_cols]
            else:
                headers = None
            df = pd.DataFrame(rows, columns=headers)

            # 安全处理工作表名，超出部分用默认名称
            name = sheet_names[idx] if idx < len(sheet_names) else f"表格{idx + 1}"
            tables_data.append((name, df))
            print(f"\n【{name}】表格（{data_cols}列）:")
            print(df.head())
    return tables_data


if __name__ == "__main__":
    soup = get_page_soup(URL)
    if not soup:
        exit()

    tables = parse_tables(soup)
    if not tables:
        print("未找到表格数据")
        exit()

    # 保存到桌面Excel文件
    output_file = r"C:\Users\34151\Desktop\安康房产数据72·1·.xlsx"
    with pd.ExcelWriter(output_file, engine="openpyxl") as writer:
        for name, df in tables:
            df.to_excel(writer, sheet_name=name, index=False)

    print(f"\n✅ 所有表格已完整保存到桌面：{output_file}")

 

2025010160韩俊杰

红外追踪

 

import cv2
import numpy as np

cap = cv2.VideoCapture(0)
# 存储轨迹点
track_points = []

# 红色HSV阈值（适配普通红笔）
low_red = np.array([0, 120, 100])
high_red = np.array([10, 255, 255])

while True:
    ret, frame = cap.read()
    if not ret:
        break
    # 转换HSV识别红色
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    mask = cv2.inRange(hsv, low_red, high_red)
    # 降噪消除杂点
    kernel = np.ones((5,5), np.uint8)
    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)

    # 找红色物体轮廓
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if contours:
        # 取最大红色区域（红笔）
        max_cont = max(contours, key=cv2.contourArea)
        area = cv2.contourArea(max_cont)
        # 过滤过小噪点
        if area > 80:
            x, y, w, h = cv2.boundingRect(max_cont)
            # 画方框框住红笔
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0,255,0), 2)
            # 获取笔中心点
            center_x = x + w // 2
            center_y = y + h // 2
            track_points.append((center_x, center_y))

    # 绘制运动轨迹
    for i in range(1, len(track_points)):
        cv2.line(frame, track_points[i-1], track_points[i], (0,0,255), 2)

    cv2.imshow("红笔追踪（带轨迹）", frame)
    cv2.imshow("红色识别蒙版", mask)

    # ESC退出
    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

 

 2025010164李朋祖 音乐播放器

xt":
            current_idx = (current_idx + 1) % len(music_list)
            pygame.mixer.music.load(music_list[current_idx])
            pygame.mixer.music.play()
            print(f"正在播放：{os.path.basename(music_list[current_idx])}")
        elif cmd == "prev":
            current_idx = (current_idx - 1) % len(music_list)
            pygame.mixer.music.load(music_list[current_idx])
            pygame.mixer.music.play()
            print(f"正在播放：{os.path.basename(music_list[current_idx])}")
        elif cmd == "vol+":
            volume = min(1.0, volume + 0.1)
            pygame.mixer.music.set_volume(volume)
            print(f"当前音量：{int(volume*100)}%")
        elif cmd == "vol-":
            volume = max(0.0, volume - 0.1)
            pygame.mixer.music.set_volume(volume)
            print(f"当前音量：{int(volume*100)}%")
        else:
            print("无效指令，请重新输入！")

if __name__ == "__main__":
    console_music_player()

 

2025010168袁艺伦 向量包

 def __init__(self, *nums):
        self.data = list(nums)

    # 向量加法
    def __add__(self, other):
        if len(self.data) != len(other.data):
            raise ValueError("维度不同，无法相加")
        return Vector(*[a + b for a, b in zip(self.data, other.data)])

    # 向量减法
    def __sub__(self, other):
        if len(self.data) != len(other.data):
            raise ValueError("维度不同，无法相减")
        return Vector(*[a - b for a, b in zip(self.data, other.data)])

    # 数乘
    def __mul__(self, num):
        return Vector(*[x * num for x in self.data])

    # 点积
    def dot(self, other):
        if len(self.data) != len(other.data):
            raise ValueError("维度不同，无法计算点积")
        return sum(a * b for a, b in zip(self.data, other.data))

    # 三维向量叉积
    def cross(self, other):
        if len(self.data) != 3 or len(other.data) != 3:
            raise ValueError("叉积仅支持三维向量")
        x1, y1, z1 = self.data
        x2, y2, z2 = other.data
        return Vector(
            y1 * z2 - z1 * y2,
            z1 * x2 - x1 * z2,
            x1 * y2 - y1 * x2
        )

    # 向量模长
    def norm(self):
        return sum(x ** 2 for x in self.data) ** 0.5

    # 格式化输出
    def __repr__(self):
        return f"Vector{self.data}"


# 线性组合函数
def linear_combination(vectors, scalars):
    if len(vectors) != len(scalars):
        raise ValueError("向量与系数数量不一致")
    res = Vector(*[0]*len(vectors[0].data))
    for vec, s in zip(vectors, scalars):
        res = res + vec * s
    return res


# ========== 测试示例 ==========
if __name__ == "__main__":
    v1 = Vector(1, 2, 3)
    v2 = Vector(4, 5, 6)

    print("加法：", v1 + v2)
    print("减法：", v1 - v2)
    print("数乘：", v1 * 2)
    print("点积：", v1.dot(v2))
    print("叉积：", v1.cross(v2))
    print("模长：", v1.norm())

    # 线性组合
    print("线性组合：", linear_combination([v1, v2], [2, -1]))

 

2025010172 张景悦
游戏角色
# 游戏角色父类
class GameRole:
    def __init__(self, hp, atk):
        self.hp = hp       # 血量
        self.atk = atk     # 攻击力（改用atk，不和方法名冲突）

    def attack(self):
        """攻击方法"""
        pass

    def move(self):
        """移动方法"""
        pass

    def show_info(self):
        print(f"当前血量：{self.hp}，攻击力：{self.atk}")
# 战士
class Warrior(GameRole):
    def attack(self):
        print(f"战士挥剑近战攻击，造成 {self.atk} 点伤害")

    def move(self):
        print("战士稳步向前冲锋")
# 法师
class Mage(GameRole):
    def attack(self):
        print(f"法师释放魔法，造成 {self.atk} 点法术伤害")

    def move(self):
        print("法师灵活小步走位")
# 弓箭手
class Archer(GameRole):
    def attack(self):
        print(f"弓箭手拉弓射箭，造成 {self.atk} 点远程伤害")

    def move(self):
        print("弓箭手快速后撤拉开距离")
# 测试多态
if __name__ == "__main__":
    role_list = [
        Warrior(150, 30),
        Mage(80, 45),
        Archer(100, 35)
    ]

    for role in role_list:
        role.show_info()
        role.move()
        role.attack()
        print("-" * 30)

 

 

 杨云飞2025010173

滴滴打车的类

class Passenger:
    def __init__(self, name, location):
        self.name = name
        self.location = location  # (x, y)
        self.order = None  # 当前订单

    def request_ride(self, destination):
        """发起打车请求"""
        self.order = Order(self, destination)
        print(f"{self.name} 在{self.location}叫车去{destination}")
        return self.order

class Driver:
    def __init__(self, name, location):
        self.name = name
        self.location = location
        self.status = "空闲"  # 状态：空闲/接单中
        self.current_order = None

    def accept_order(self, order):
        """接单操作"""
        self.status = "接单中"
        self.current_order = order
        order.driver = self
        print(f"{self.name} 接单，前往{order.passenger.location}")

    def finish_order(self):
        """完成订单"""
        self.status = "空闲"
        self.current_order.finish()
        self.current_order = None

class Order:
    def __init__(self, passenger, destination):
        self.passenger = passenger
        self.destination = destination
        self.driver = None
        self.status = "待接单"
        self.distance = 0
        self.cost = 0

    def calculate_cost(self):
        """简单计价：5元起步 + 2元/公里"""
        self.distance = self.calculate_distance()
        self.cost = 5 + self.distance * 2

    def calculate_distance(self):
        """计算两点距离"""
        x1, y1 = self.passenger.location
        x2, y2 = self.destination
        return round(((x2-x1)**2 + (y2-y1)**2)**0.5, 1)

    def finish(self):
        """结束订单"""
        self.status = "已完成"
        print(f"订单完成！距离{self.distance}公里，费用{self.cost}元")

class DidiApp:
    def __init__(self):
        self.passengers = []
        self.drivers = []

    def add_passenger(self, passenger):
        self.passengers.append(passenger)

    def add_driver(self, driver):
        self.drivers.append(driver)

    def find_driver(self, passenger):
        """简单匹配最近司机"""
        closest_driver = None
        min_distance = float('inf')
        for driver in self.drivers:
            if driver.status == "空闲":
                distance = ((passenger.location[0]-driver.location[0])**2 +
                           (passenger.location[1]-driver.location[1])**2)**0.5
                if distance < min_distance:
                    min_distance = distance
                    closest_driver = driver
        return closest_driver

    def process_order(self, order):
        """处理订单流程"""
        driver = self.find_driver(order.passenger)
        if driver:
            driver.accept_order(order)
            order.calculate_cost()
        else:
            print("没有可用司机")

# 使用示例
if __name__ == "__main__":
    # 创建平台
    didi = DidiApp()

    # 创建乘客和司机
    passenger = Passenger("小明", (1, 2))
    driver = Driver("王师傅", (3, 4))
    
    # 添加到平台
    didi.add_passenger(passenger)
    didi.add_driver(driver)

    # 乘客叫车
    order = passenger.request_ride((5, 6))
    didi.process_order(order)

    # 司机完成订单
    driver.finish_order()