25级第七次实验报告
| 2025010089 | 1 |
| 2025010090 | 1 |
| 2025010091 | 1 |
| 2025010092 | 1 |
| 2025010093 | 1 |
| 2025010094 | 1 |
| 2025010095 | 1 |
| 2025010096 | 1 |
| 2025010097 | 1 |
| 2025010098 | 1 |
| 2025010099 | 1 |
| 2025010100 | 1 |
| 2025010101 | 1 |
| 2025010102 |
1 |
| 2025010103 | 1 |
| 2025010104 | 1 |
| 2025010105 | |
| 2025010106 | |
| 2025010107 |
1 |
| 2025010108 | |
| 2025010109 | |
| 2025010110 | |
| 2025010112 | 1 |
| 2025010113 | 1 |
| 2025010114 | 1 |
| 2025010115 | 1 |
| 2025010117 | 1 |
| 2025010118 | 1 |
| 2025010119 | 1 |
| 2025010120 | |
| 2025010121 | 1 |
| 2025010122 | |
| 2025010124 | 1 |
| 2025010125 | 1 |
| 2025010126 | |
| 2025010127 | 1 |
| 2025010128 | 1 |
| 2025010130 | 1 |
| 2025010131 | 1 |
| 2025010132 | 1 |
2025010089张静文
爬取豆瓣财富榜
# 修复中文编码 import sys sys.stdout.reconfigure(encoding="utf-8") import requests from bs4 import BeautifulSoup # 完整浏览器请求头，骗过豆瓣反爬 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", "Referer": "https://book.douban.com/", "Accept-Language": "zh-CN,zh;q=0.9" } if __name__ == "__main__": print("======= 豆瓣财富类书籍爬取结果 =======") # 爬取前3页 for page_num in range(0, 3): offset = page_num * 20 url = f"https://book.douban.com/tag/财富?start={offset}" print(f"\n正在爬取第{page_num + 1}页...") try: response = requests.get(url, headers=headers, timeout=15) response.encoding = "utf-8" soup = BeautifulSoup(response.text, "html.parser") book_items = soup.find_all("li", class_="subject-item") # 遍历每一本书 for item in book_items: # 精准提取书名标签 title_tag = item.find("div", class_="info").find("a") book_name = title_tag.get("title").strip() # 出版信息 pub_tag = item.find("div", class_="pub") pub_info = pub_tag.get_text(strip=True) if pub_tag else "无信息" # 评分 score_tag = item.find("span", class_="rating_nums") score = score_tag.get_text(strip=True) if score_tag else "暂无评分" print(f"书名：{book_name} | 评分：{score} | 出版：{pub_info}") except Exception as e: print(f"第{page_num + 1}页异常：{e}") print("\n全部页面爬取完成！")
2025010090殷慧湘
# 房东
class Landlord:
def __init__(self,name):
self.name=name
def send_house(self,house):
print(f"{self.name}发布房源：{house}")
return house
# 租客
class Tenant:
def __init__(self,name):
self.name=name
def look_house(self,house):
print(f"{self.name}预约看房：{house}")
def pay(self,money):
print(f"{self.name}缴费{money}元")
# 中介
class Agent:
def __init__(self,name):
self.name=name
def show_house(self,house):
print(f"中介{self.name}展示房源：{house}")
def sign(self,landlord,tenant,house,fee):
print(f"\n三方签约完成！房源：{house}")
tenant.pay(fee)
# 完整简易流程
if __name__=="__main__":
# 创建三方
fangdong=Landlord("王房东")
zuke=Tenant("小明")
zhongjie=Agent("李中介")
# 1.房东发布房源
house=fangdong.send_house("一室一厅 1800/月")
# 2.中介上架展示
zhongjie.show_house(house)
# 3.租客看房
zuke.look_house(house)
# 4.中介组织签约缴费
zhongjie.sign(fangdong,zuke,house,3600)
2025010091张译心
爬取学校网站
import requests from bs4 import BeautifulSoup import time # 请求头模拟浏览器 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" } # 安康学院院系设置页面（可自行替换最新官网地址） url = "https://www.aku.edu.cn/xyjs.htm" def get_aku_colleges(): try: resp = requests.get(url, headers=headers, timeout=10) resp.encoding = "utf-8" soup = BeautifulSoup(resp.text, "lxml") college_list = [] # 自行根据官网html标签修改选择器，示例通用筛选逻辑 items = soup.select(".xy-list li a") for item in items: col_name = item.get_text(strip=True) if "学院" in col_name: college_list.append(col_name) # 分类映射（安康学院12个二级学院） type_map = { "数学与统计学院": "理学类", "化学与环境学院": "理学类", "电子与信息工程学院": "工学类", "文学与传媒学院": "人文文学类", "外语学院（国际教育学院）": "人文文学类", "马克思主义学院": "思政通识类", "教育学院": "教育师范类", "体育学院": "教育师范类", "艺术学院": "艺术类", "经济与管理学院": "经管商科类", "现代农业与生物科技学院": "农学特色类", "医学院": "医学类" } # 学院标准职务 duty_list = [ "党总支书记", "党总支副书记", "院长", "副院长", "教研室主任", "党支部书记", "教学秘书", "学工办主任", "辅导员" ] # 打印结果 print("===== 安康学院二级学院统计 =====") print(f"学院总数量：{len(college_list)}") print("\n各学院及类型：") for name, ctype in type_map.items(): print(f"- {name} 【{ctype}】") print("\n===== 学院通用职务 =====") for duty in duty_list: print(f"- {duty}") # 保存到txt文件 with open("安康学院院系信息.txt", "w", encoding="utf-8") as f: f.write(f"安康学院二级学院总数：{len(type_map)}\n\n") f.write("学院-类型列表：\n") for name, ctype in type_map.items(): f.write(f"{name} | {ctype}\n") f.write("\n院内职务：\n") for d in duty_list: f.write(d + "\n") print("\n数据已保存至：安康学院院系信息.txt") except Exception as e: print("爬取失败：", str(e)) if __name__ == "__main__": time.sleep(1) get_aku_colleges()
2025010092朱翔鸽
import requests import matplotlib.pyplot as plt # ===================== 1. 配置请求头（豆瓣反爬必须） ===================== 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" } # 豆瓣电影榜单Ajax接口（滚动加载JSON接口） # start分页参数，每次加载20条，可修改start=0/20/40实现下拉翻页 url = "https://movie.douban.com/j/chart/top_list?type=11&interval_id=100:90&action=&start=0&limit=20" # ===================== 2. 发送Ajax请求，获取JSON数据 ===================== response = requests.get(url, headers=headers) json_data = response.json() # 解析数据：提取电影名、评分 movie_names = [] movie_scores = [] for movie in json_data: title = movie["title"] score = float(movie["rating"][0]) movie_names.append(title) movie_scores.append(score) # ===================== 3. matplotlib绘制柱状图 ===================== # 解决matplotlib中文乱码 plt.rcParams["font.sans-serif"] = ["SimHei"] plt.rcParams["axes.unicode_minus"] = False # 设置画布大小 plt.figure(figsize=(14, 7), dpi=100) # 绘制柱状图 bars = plt.bar(movie_names, movie_scores, color="#4188d9", alpha=0.8) # 在每个柱子顶部标注评分 for bar, score in zip(bars, movie_scores): height = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2, height + 0.03, f"{score}", ha="center", fontsize=9) # 图表配置 plt.title("豆瓣电影排行榜评分柱状图（Ajax接口JSON数据）", fontsize=15, pad=20) plt.xlabel("电影名称", fontsize=12) plt.ylabel("豆瓣评分", fontsize=12) plt.ylim(8.5, 10) # 评分区间优化显示 plt.xticks(rotation=45, ha="right") # x轴名称旋转防止重叠 plt.grid(axis="y", linestyle="--", alpha=0.3) plt.tight_layout() # 自动适配布局，避免文字截断 # 保存图片+展示 plt.savefig("豆瓣电影评分柱状图.png") plt.show() print("图表已生成：豆瓣电影评分柱状图.png") print(f"共抓取{len(movie_names)}条电影数据")
2025010093惠盾
拖拽图片
import tkinter as tk from PIL import Image, ImageTk class DragImageWindow: def __init__(self, root, img_path): self.root = root # 加载图片 self.image = Image.open(img_path) self.photo = ImageTk.PhotoImage(self.image) # 创建画布承载图片 self.canvas = tk.Canvas(root, width=800, height=600, bg="white") self.canvas.pack(fill=tk.BOTH, expand=True) # 在画布绘制图片，保存图片id self.img_id = self.canvas.create_image(400, 300, image=self.photo) # 拖拽坐标记录 self.drag_x = 0 self.drag_y = 0 # 绑定鼠标事件 self.canvas.bind("<Button-1>", self.on_mouse_down) # 左键按下 self.canvas.bind("<B1-Motion>", self.on_mouse_move) # 按住拖动 def on_mouse_down(self, event): # 记录按下时鼠标坐标 self.drag_x = event.x self.drag_y = event.y def on_mouse_move(self, event): # 计算偏移量 dx = event.x - self.drag_x dy = event.y - self.drag_y # 移动画布上的图片 self.canvas.move(self.img_id, dx, dy) # 更新拖拽起点 self.drag_x = event.x self.drag_y = event.y if __name__ == "__main__": window = tk.Tk() window.title("拖拽移动图片") window.geometry("800x600") # ========= 修改这里为你的图片路径 ========= IMG_FILE = "111.jpg" # ========================================= try: app = DragImageWindow(window, IMG_FILE) except Exception as e: print(f"图片加载失败，请检查路径：{e}") window.mainloop()
2025010095徐雨轩
加载俄罗斯方块游戏界面
# tkinter纯内置，不用安装任何库，棋盘+自带固定方块 from tkinter import * BLOCK = 30 COL = 10 ROW = 20 W = BLOCK * COL H = BLOCK * ROW root = Tk() root.title("俄罗斯方块") canvas = Canvas(root, width=W, height=H, bg="#333333") canvas.pack() # 绘制网格 for x in range(COL + 1): canvas.create_line(x*BLOCK, 0, x*BLOCK, H, fill="white") for y in range(ROW + 1): canvas.create_line(0, y*BLOCK, W, y*BLOCK, fill="white") # 手动画上4个彩色方块（I型小方块） def draw_block(x, y, color): canvas.create_rectangle(x*BLOCK+1, y*BLOCK+1, (x+1)*BLOCK-1, (y+1)*BLOCK-1, fill=color) # 在棋盘里摆放方块 draw_block(3, 2, "#ff3333") draw_block(4, 2, "#ffcc00") draw_block(5, 2, "#33ccff") draw_block(4, 3, "#33ff66") root.mainloop()
2025010096 刘加鑫
from PIL import Image from tkinter import Tk, filedialog def mosaic_pil(img_path, save_path, block=12): img = Image.open(img_path) w, h = img.size small = img.resize((w // block, h // block), Image.NEAREST) mosaic = small.resize((w, h), Image.NEAREST) mosaic.save(save_path) mosaic.show() print("马赛克图片保存完成") if __name__ == "__main__": root = Tk() root.withdraw() # 弹窗默认打开桌面NBA文件夹 pic_path = filedialog.askopenfilename( initialdir=r"C:\Users\HP\Desktop\NBA", title="选择要模糊的图片", filetypes=[("图片", "*.jpg;*.jpeg;*.png;*.bmp")] ) if pic_path: # 处理后的图片直接存到NBA文件夹里 output = r"C:\Users\HP\Desktop\NBA\马赛克成品.jpg" mosaic_pil(pic_path, output, block=12)
2025010097马浩
报道流程
class Student: def __init__(self, name, id_card, tuition_paid=False): self.name = name self.id_card = id_card self.tuition_paid = tuition_paid self.supplies = [] self.class_no = None self.dorm = None class SchoolEntry: def __init__(self): self.entry_step = ["报到登记", "证件核验", "学费缴纳", "生活用品领取", "分班", "宿舍入住"] def register(self, stu): print(f"【步骤1：报到登记】{stu.name}完成新生信息登记") return True def check_id(self, stu): if len(stu.id_card) == 18: print(f"【步骤2：证件核验】{stu.name}证件审核通过") return True else: print(f"【步骤2：证件核验】{stu.name}证件无效，无法入校") return False def pay_fee(self, stu): if stu.tuition_paid: print(f"【步骤3：学费缴纳】{stu.name}学费已缴清") return True else: print(f"【步骤3：学费缴纳】{stu.name}未缴费，暂停入校") return False # 下面全部缩进在类里面！！ def get_supply(self, stu): supply_list = ["被褥", "校服", "校园卡"] stu.supplies = supply_list print(f"【步骤4：物资领取】{stu.name}领取：{supply_list}") def assign_class(self, stu, cls): stu.class_no = cls print(f"【步骤5：分班】{stu.name}分配至{cls}") def arrange_dorm(self, stu, dorm): stu.dorm = dorm print(f"【步骤6：入住】{stu.name}入住宿舍{dorm}，入校全部完成\n") def full_entry(self, student, class_num, dorm_num): if not self.register(student): return if not self.check_id(student): return if not self.pay_fee(student): return self.get_supply(student) self.assign_class(student, class_num) self.arrange_dorm(student, dorm_num) # 必须加这段启动代码！！ if __name__ == "__main__": s1 = Student("张三", "610101200812341234", True) entry = SchoolEntry() entry.full_entry(s1, "高一3班", "3公寓402")
2025010098韩晓媛
试卷信度
import random import pandas as pd import numpy as np # ---------------------- 学生数据 ---------------------- def generate_test_data(student_num=30, question_num=8, full_score=10): # 模拟人名库 first_name = ["张", "李", "王", "刘", "陈", "杨", "黄", "赵", "周", "吴"] last_name = ["伟", "芳", "娜", "强", "磊", "敏", "静", "杰", "婷", "宇"] student_names = [] for _ in range(student_num): name = random.choice(first_name) + random.choice(last_name) student_names.append(name) # 得分矩阵：每行1个学生，每列1道题得分(0~满分) score_matrix = [] for _ in range(student_num): single_student = [random.randint(0, full_score) for _ in range(question_num)] score_matrix.append(single_student) # 转为DataFrame方便打印 col_names = [f"第{i+1}题" for i in range(question_num)] df = pd.DataFrame(score_matrix, columns=col_names) df.insert(0, "姓名", student_names) return df, np.array(score_matrix) # ---------------------- 2. 计算克朗巴哈α信度系数 ---------------------- def cronbach_alpha(data): """ data: 二维数组 [学生数, 题目数] return: α系数 """ n_items = data.shape[1] # 每道题的方差 var_item = np.var(data, axis=0, ddof=1) # 总分方差 total_score = np.sum(data, axis=1) var_total = np.var(total_score, ddof=1) # α公式 alpha = (n_items / (n_items - 1)) * (1 - np.sum(var_item) / var_total) return round(alpha, 4) # ---------------------- 3. 运行 ---------------------- if __name__ == "__main__": # 参数设置：30名学生，8道试题，每题满分10分 df_score, score_array = generate_test_data(student_num=30, question_num=8, full_score=10) # 打印学生得分表 print("===== 模拟试卷得分数据表 =====") print(df_score.to_string(index=False)) # 计算信度 alpha_value = cronbach_alpha(score_array) print("\n===== 试卷信度分析结果 =====") print(f"克朗巴哈α系数：{alpha_value}") # 信度评价标准 print("\n信度判定标准：") if alpha_value >= 0.9: level = "优秀，试卷内部一致性极佳" elif alpha_value >= 0.8: level = "良好，试卷信度较好" elif alpha_value >= 0.7: level = "可接受，可用于基础测评" elif alpha_value >= 0.6: level = "勉强可用，题目需要调整优化" else: level = "不合格，试卷题目区分度差，需大幅修改" print(f"评价结果：{level}")
2025010099张嘉诚
用类处理Excel
from openpyxl import load_workbook
from typing import List, Optional, Tuple
class ExcelDataProcessor:
"""
Excel数据处理工具类：
1. 读取数值数据（自动过滤空行，区分表头）
2. 按指定列升序/降序排序
3. 将数据写回Excel（支持新建工作表、清空原数据）
4. 复制工作表（保留格式）
"""
def __init__(self, file_path: str):
"""
初始化并加载Excel文件
:param file_path: Excel文件路径（.xlsx）
"""
self.file_path = file_path
# data_only=True：只读取单元格计算后的值，不读取公式
self.workbook = load_workbook(file_path, data_only=True)
# 缓存数据
self._header: Optional[List] = None
self._data: List[List] = []
def read_data(self, sheet_name: str, has_header: bool = True) -> Tuple[Optional[List], List[List]]:
"""
读取指定工作表的数据，自动跳过空行
:param sheet_name: 工作表名称
:param has_header: 是否包含表头（第一行）
:return: (表头列表, 数据列表)
"""
if sheet_name not in self.workbook.sheetnames:
raise ValueError(f"工作表不存在：{sheet_name}，可用表：{self.workbook.sheetnames}")
ws = self.workbook[sheet_name]
rows = []
# 读取所有行
for row in ws.iter_rows(values_only=True):
# 跳过全空行
if all(cell is None for cell in row):
continue
rows.append(list(row))
if not rows:
raise ValueError("工作表中没有有效数据")
# 拆分表头和数据
if has_header:
self._header = rows[0]
self._data = rows[1:]
else:
self._header = None
self._data = rows
print(f"✅ 读取完成：表头={self._header}，共{len(self._data)}行数据")
return self._header, self._data
def sort_data(self, sort_col: int, ascending: bool = True) -> List[List]:
"""
按指定列对数据进行排序
:param sort_col: 排序列索引（从0开始，A列=0，B列=1...）
:param ascending: True=升序，False=降序
:return: 排序后的数据
"""
if not self._data:
raise ValueError("无数据可排序，请先调用read_data()")
# 校验列索引
max_col = len(self._data[0]) - 1
if sort_col < 0 or sort_col > max_col:
raise ValueError(f"列索引非法，有效范围：0~{max_col}")
# 排序逻辑：优先按数值排序，失败则按字符串排序
try:
self._data.sort(
key=lambda x: x[sort_col] if x[sort_col] is not None else 0,
reverse=not ascending
)
except TypeError:
# 数值排序失败时，回退到字符串排序
self._data.sort(
key=lambda x: str(x[sort_col]) if x[sort_col] is not None else "",
reverse=not ascending
)
order = "升序" if ascending else "降序"
print(f"✅ 排序完成：按第{sort_col+1}列{order}排列")
return self._data
def write_data(
self,
sheet_name: str,
start_row: int = 1,
start_col: int = 1,
clear_old: bool = False
):
"""
将当前数据写回指定工作表
:param sheet_name: 目标工作表名（不存在则自动创建）
:param start_row: 写入起始行（从1开始）
:param start_col: 写入起始列（从1开始）
:param clear_old: 是否先清空目标工作表原有数据
"""
if not self._data:
raise ValueError("无数据可写入，请先读取或排序数据")
# 不存在则新建工作表
if sheet_name not in self.workbook.sheetnames:
self.workbook.create_sheet(sheet_name)
print(f"📄 自动创建工作表：{sheet_name}")
ws = self.workbook[sheet_name]
# 清空原有数据
if clear_old:
ws.delete_rows(1, ws.max_row)
print(f"🧹 已清空工作表【{sheet_name}】原有数据")
# 写入表头
if self._header is not None:
for i, val in enumerate(self._header):
ws.cell(row=start_row, column=start_col + i, value=val)
start_row += 1
# 写入数据
for row in self._data:
for i, val in enumerate(row):
ws.cell(row=start_row, column=start_col + i, value=val)
start_row += 1
print(f"✅ 写入完成：共{len(self._data)}行数据写入【{sheet_name}】")
def copy_sheet(self, source: str, target: str):
"""
复制工作表（保留格式、公式、数据）
:param source: 源工作表名
:param target: 目标工作表名
"""
if source not in self.workbook.sheetnames:
raise ValueError(f"源工作表不存在：{source}")
ws_source = self.workbook[source]
ws_target = self.workbook.copy_worksheet(ws_source)
ws_target.title = target
print(f"📋 工作表复制完成：{source} → {target}")
def save(self, path: Optional[str] = None):
"""
保存Excel文件
:param path: 保存路径，不传则覆盖原文件
"""
save_path = path or self.file_path
self.workbook.save(save_path)
print(f"💾 文件已保存：{save_path}")
def close(self):
"""关闭工作簿，释放资源"""
self.workbook.close()
print("🔒 工作簿已关闭")
# ---------------------- 使用示例 ----------------------
if __name__ == "__main__":
# 1. 初始化处理器（替换为你的文件路径）
processor = ExcelDataProcessor("2025年销售数据明细.xlsx")
try:
# 2. 读取数据（工作表名替换为你的表名）
processor.read_data(sheet_name="2025年销售数据明细", has_header=True)
# 3. 按第2列（索引1）降序排序
processor.sort_data(sort_col=5, ascending=False)
# 4. 复制原工作表做备份
processor.copy_sheet(source="2025年销售数据明细", target="2025年销售数据明细")
# 5. 将排序后的数据写回原表（清空原数据）
processor.write_data(sheet_name="2025年销售数据明细", clear_old=True)
# 6. 也可以写入新表
processor.write_data(sheet_name="排序结果", clear_old=True)
# 7. 保存文件
processor.save()
except Exception as e:
print(f"❌ 处理出错：{e}")
finally:
processor.close()
2025010100霍延萌
龙生九子
# 父类：龙
class Dragon:
def ability(self):
"""九子各有神通，子类重写该方法实现多态"""
pass
# 1. 囚牛：好音律，琴头雕刻
class QiuNiu(Dragon):
def ability(self):
return "囚牛：喜好音律，常刻于琴头"
# 2. 睚眦：好杀，刀剑吞口
class YaZi(Dragon):
def ability(self):
return "睚眦：好勇善斗，刻于刀剑吞口"
# 3. 嘲风：好险，殿角走兽
class ChaoFeng(Dragon):
def ability(self):
return "嘲风：喜好登高涉险，立于殿角屋檐"
# 4. 蒲牢：好鸣，钟上兽钮
class PuLao(Dragon):
def ability(self):
return "蒲牢：生性好鸣，铸为大钟兽钮"
# 5. 狻猊：好坐，喜烟火，香炉
class SuanNi(Dragon):
def ability(self):
return "狻猊：喜静好坐，常盘踞香炉之上"
# 6. 霸下（赑屃）：负重，驮石碑
class BaXia(Dragon):
def ability(self):
return "霸下(赑屃)：力大无穷，常年驮载石碑"
# 7. 狴犴：好讼，狱门官衙
class BiAn(Dragon):
def ability(self):
return "狴犴：明辨是非，装饰牢狱、官衙大门"
# 8. 负屃：好文，碑侧文龙
class FuXi(Dragon):
def ability(self):
return "负屃：酷爱文采，盘绕石碑文字两侧"
# 9. 螭吻：吞火，屋脊镇火
class ChiWen(Dragon):
def ability(self):
return "螭吻：喜吞水火，安于屋脊镇邪避火"
# 多态统一调用函数
def show_dragon_skill(dragon: Dragon):
# 接收任意龙子类对象，统一调用ability，自动匹配子类实现（多态）
print(dragon.ability())
if __name__ == "__main__":
# 实例化九子
nine_sons = [
QiuNiu(),
YaZi(),
ChaoFeng(),
PuLao(),
SuanNi(),
BaXia(),
BiAn(),
FuXi(),
ChiWen()
]
print("===== 龙生九子，各有所好（继承+多态演示）=====\n")
# 循环统一调用，体现多态特性
for son in nine_sons:
show_dragon_skill(son)
2025010101袁泉
求形状面积
import math # 图形基类 class Shape: def get_area(self): pass # 三角形 class Triangle(Shape): def __init__(self, base, height): self.base = base self.height = height def get_area(self): return self.base * self.height / 2 # 矩形 class Rectangle(Shape): def __init__(self, w, h): self.w = w self.h = h def get_area(self): return self.w * self.h # 圆形 class Circle(Shape): def __init__(self, r): self.r = r def get_area(self): return math.pi * self.r ** 2 def main(): # 房屋参数：屋顶三角+墙体矩形-圆孔窗户 roof = Triangle(6, 3) wall = Rectangle(6, 5) window = Circle(1) total = roof.get_area() + wall.get_area() - window.get_area() print(f"屋顶:{roof.get_area():.2f},墙体:{wall.get_area():.2f},窗户:{window.get_area():.2f}") print(f"房屋总面积:{total:.2f}") if __name__ == "__main__": main()
2025010102沈玉婷
# 工人类
class Gongren:
def __init__(self, name):
self.name = name
def shuidian(self):
print(f"{self.name}水电")
def mugong(self):
print(f"{self.name}木工")
def shuaqiang(self):
print(f"{self.name}刷墙")
# 设计师
class Shejishi:
def __init__(self, name):
self.name = name
def shineisheji(self):
print(f"{self.name}室内设计")
def jiajubaifang(self):
print(f"{self.name}家具摆放")
# 被装修类
class Beizhuangxiu:
def __init__(self, name):
self.name = name
def pay(self):
print(f"{self.name}付钱")
def goumaijiaju(self):
print(f"{self.name}购买家具")
# 主流程：创建角色并按顺序调用方法
if __name__ == "__main__":
gongren = Gongren("张三")
shejishi = Shejishi("小明")
beizhuangxiu = Beizhuangxiu("老王")
gongren.shuidian()
gongren.mugong()
gongren.shuaqiang()
shejishi.shineisheji()
shejishi.jiajubaifang()
beizhuangxiu.pay()
beizhuangxiu.goumaijiaju()
2025010103黄俊
装修流程
class Decoration: # 定义装修完整流程 process_list = ["主体拆改", "水电改造", "泥瓦工程", "木工工程", "油漆工程", "安装环节", "软装进场", "完工验收"] def __init__(self, house_area, owner_name): # 初始化：房屋面积、业主、当前工序、完成状态 self.house_area = house_area self.owner_name = owner_name self.current_step = 0 self.is_finish = False def start_work(self): """开始装修""" print(f"业主{self.owner_name}，{self.house_area}㎡房屋，装修正式开工！") def next_process(self): """进行下一道工序""" if self.is_finish: print("装修已全部完工，无需继续施工！") return # 获取当前工序名称 current_name = Decoration.process_list[self.current_step] print(f"正在施工：{current_name}") self.current_step += 1 # 判断是否全部完成 if self.current_step >= len(Decoration.process_list): self.is_finish = True print("所有工序完成，装修验收通过！") def show_progress(self): """查看当前装修进度""" if self.is_finish: print("装修状态：已全部完工") return progress = self.current_step / len(Decoration.process_list) * 100 now_step = Decoration.process_list[self.current_step] print(f"当前工序：{now_step}，整体进度：{progress:.1f}%") # 主程序调用 if __name__ == "__main__": # 创建装修实例：面积100平，业主小李 my_house = Decoration(100, "小李") my_house.start_work() # 依次执行所有工序 for _ in range(len(Decoration.process_list)): my_house.next_process() my_house.show_progress()
2025010104许乐乐
import numpy as np import matplotlib.pyplot as plt # 兼容Windows系统字体，彻底消除中文警告 plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"] plt.rcParams["axes.unicode_minus"] = False # 正常显示坐标轴负号 # 1. 定义损失函数 z = x² + 3y² def f(x, y): return x ** 2 + 3 * (y ** 2) # 2. 求梯度（上升最快方向），负梯度是下降最快方向 def gradient(x, y): df_dx = 2 * x df_dy = 6 * y return np.array([df_dx, df_dy]) # 3. 梯度下降迭代，保存每一步路径 def gradient_descent(start_x, start_y, lr=0.1, epoch=30): path = [] x, y = start_x, start_y for _ in range(epoch): path.append([x, y]) grad = gradient(x, y) # 沿负梯度更新（下降最快路线） x = x - lr * grad[0] y = y - lr * grad[1] path.append([x, y]) return np.array(path) # 生成等高线网格 x_range = np.linspace(-6, 6, 100) y_range = np.linspace(-6, 6, 100) X, Y = np.meshgrid(x_range, y_range) Z = f(X, Y) # 执行梯度下降 path = gradient_descent(start_x=-5, start_y=5, lr=0.1, epoch=30) # 绘图 plt.figure(figsize=(8, 6)) contour = plt.contour(X, Y, Z, levels=30, cmap="coolwarm") plt.clabel(contour, inline=True, fontsize=8) # 绘制下降路径 plt.plot(path[:, 0], path[:, 1], color="red", linewidth=2, marker="o", markersize=4, label="梯度下降最快路径") plt.scatter(path[0, 0], path[0, 1], color="blue", s=80, label="迭代起点") plt.scatter(path[-1, 0], path[-1, 1], color="green", s=80, label="收敛最低点") plt.xlabel("参数 x") plt.ylabel("参数 y") plt.title("梯度下降：负梯度为损失下降最快路径（等高线图）") plt.legend() plt.axis("equal") plt.show() # 打印每一步迭代数据 print("梯度下降每一步坐标（最快下降路径）：") for idx, point in enumerate(path): print(f"第{idx:2d}步: x={point[0]:.3f}, y={point[1]:.3f}, loss={f(point[0], point[1]):.3f}")
2025010107孙瑞妍
import time
# 商品类
class Goods:
def __init__(self, gid, name, price, stock):
self.gid = gid # 商品ID
self.name = name # 商品名称
self.price = price # 单价
self.stock = stock # 库存
# 购物车类
class Cart:
def __init__(self):
self.cart_list = [] # [(Goods对象,购买数量)]
# 添加商品进购物车
def add_goods(self, goods, num):
if goods.stock < num:
print(f"【库存不足】{goods.name}仅剩{goods.stock}件")
return False
# 商品已在购物车则累加数量
for idx, (g, n) in enumerate(self.cart_list):
if g.gid == goods.gid:
self.cart_list[idx] = (g, n + num)
return True
self.cart_list.append((goods, num))
print(f"成功加入购物车：{goods.name} ×{num}")
return True
# 计算购物车总价
def get_total(self):
total = 0
for g, n in self.cart_list:
total += g.price * n
return round(total, 2)
# 清空购物车
def clear(self):
self.cart_list = []
# 订单类
class Order:
def __init__(self, order_id, goods_info, total_price):
self.order_id = order_id
self.goods_info = goods_info # 下单商品明细
self.total = total_price
self.status = "待商家接单" # 订单状态：待接单/已发货/待收货/已完成
# 用户类
class Buyer:
def __init__(self, username):
self.username = username
self.cart = Cart()
self.order_list = [] # 用户全部订单
# 提交订单
def submit_order(self, order_id):
if not self.cart.cart_list:
print("购物车为空，无法下单！")
return None
total = self.cart.get_total()
# 扣减商品库存
for g, num in self.cart.cart_list:
g.stock -= num
# 生成订单
new_order = Order(order_id, self.cart.cart_list.copy(), total)
self.order_list.append(new_order)
print(f"\n【{self.username}下单成功】订单号：{order_id}，实付金额：{total}元")
self.cart.clear() # 下单清空购物车
return new_order
# 商家类
class Seller:
def __init__(self, shop_name):
self.shop_name = shop_name
self.wait_order = [] # 待处理订单
# 接收用户订单
def receive_order(self, order):
self.wait_order.append(order)
print(f"\n【商家{self.shop_name}收到新订单{order.order_id}，状态：{order.status}】")
# 商家发货
def send_goods(self, order_id):
for order in self.wait_order:
if order.order_id == order_id and order.status == "待商家接单":
order.status = "已发货，等待买家收货"
print(f"【商家{self.shop_name}操作】订单{order_id}已打包发货！")
return True
print("订单不存在或无法发货")
return False
# 主流程模拟
if __name__ == '__main__':
# 1.创建商家+上架商品
tb_seller = Seller("淘宝优品旗舰店")
g1 = Goods(1001, "纯棉T恤", 59.9, 100)
g2 = Goods(1002, "休闲牛仔裤", 129.9, 50)
# 2.创建买家用户
user = Buyer("淘宝小买家001")
# 3.用户浏览加购
print("=====1.用户挑选商品加入购物车=====")
user.cart.add_goods(g1, 2)
user.cart.add_goods(g2, 1)
print(f"购物车合计：{user.cart.get_total()}元")
# 4.用户提交订单
print("\n=====2.用户提交订单=====")
order_no = "TB20260603001"
my_order = user.submit_order(order_no)
# 5.商家接收订单
tb_seller.receive_order(my_order)
# 6.商家发货
print("\n=====3.商家处理订单、发货=====")
tb_seller.send_goods(order_no)
# 7.用户确认收货，订单完结
time.sleep(1)
my_order.status = "订单已完成，交易结束"
print(f"\n=====4.买家确认收货=====\n订单{order_no}最终状态：{my_order.status}")
2025010112 王怡萱
变调
import wave import math import struct def gen_human_voice(duration=3, base_freq=110): """生成模拟人声音波（基频+泛音，男声基底）""" framerate = 22050 total_frames = framerate * duration volume = 26000 data = [] for frame in range(total_frames): t = frame / framerate # 基音 + 2层泛音，模拟人声质感 base = math.sin(2 * math.pi * base_freq * t) overtone1 = 0.4 * math.sin(2 * math.pi * base_freq * 2 * t) overtone2 = 0.2 * math.sin(2 * math.pi * base_freq * 3 * t) wave_sum = base + overtone1 + overtone2 val = int(wave_sum * volume) data.append(struct.pack('<h', val)) raw_bytes = b''.join(data) return framerate, raw_bytes def pitch_shift(sample_rate, raw_data, semitone): """变调函数，修改采样率实现升降调""" rate = 2 ** (semitone / 12) new_sr = int(sample_rate * rate) return new_sr, raw_data def save_wav(file_name, sample_rate, raw_data): wf = wave.open(file_name, 'wb') wf.setnchannels(1) wf.setsampwidth(2) wf.setframerate(sample_rate) wf.writeframes(raw_data) wf.close() print(f"已生成：{file_name}") if __name__ == "__main__": # 自动生成原生男声波形，不依赖任何外部wav音频 sr, raw = gen_human_voice(duration=3, base_freq=110) # 原生基底男声 save_wav("原生男声.wav", sr, raw) # 升6半音 → 纤细女声 sr_female, raw_f = pitch_shift(sr, raw, 6) save_wav("变调女声.wav", sr_female, raw_f) # 降6半音 → 浑厚低音男声 sr_deep, raw_d = pitch_shift(sr, raw, -6) save_wav("低音男声.wav", sr_deep, raw_d)
2025010113 石蕊鑫
龙生九子
class DragonSon: def __init__(self, name): self.name = name def hobby(self): pass # 统一展示方法，全部子类共用（继承） def show_info(self): print(f"{self.name}：", end="") self.hobby() # 1.囚牛 class QiuNiu(DragonSon): def hobby(self): print("喜好音律，立于琴头") # 2.睚眦 class YaZi(DragonSon): def hobby(self): print("好勇嗜杀，雕于兵器刀柄") # 3.嘲风 class ChaoFeng(DragonSon): def hobby(self): print("好登高望远，做殿角走兽") # 4.蒲牢 class PuLao(DragonSon): def hobby(self): print("惧怕鲸鱼，钟钮常用其形象") # 5.狻猊 class SuanNi(DragonSon): def hobby(self): print("喜静好烟火，盘踞香炉之上") # 6.霸下(赑屃) class BaXia(DragonSon): def hobby(self): print("力大好负重，驮载石碑") # 7.狴犴 class BiAn(DragonSon): def hobby(self): print("急公好义，立于牢狱衙门牌匾") # 8.负屃 class FuXi(DragonSon): def hobby(self): print("酷爱文采，盘绕石碑两侧") # 9.螭吻 class ChiWen(DragonSon): def hobby(self): print("喜吞火避灾，作屋脊吞兽") if __name__ == "__main__": nine_sons = [ QiuNiu("囚牛"), YaZi("睚眦"), ChaoFeng("嘲风"), PuLao("蒲牢"), SuanNi("狻猊"), BaXia("霸下"), BiAn("狴犴"), FuXi("负屃"), ChiWen("螭吻") ] for son in nine_sons: son.show_info()
2025010114殷佳锐
# 导入基础库 import requests import matplotlib.pyplot as plt # 设置中文显示 plt.rcParams["font.sans-serif"] = ["SimHei"] plt.rcParams["axes.unicode_minus"] = False # 存储两年电影类型计数 type_2025 = {"剧情":0, "爱情":0, "喜剧":0, "动作":0, "科幻":0, "悬疑":0} type_2024 = {"剧情":0, "爱情":0, "喜剧":0, "动作":0, "科幻":0, "悬疑":0} # 请求头伪装浏览器 headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" } # 豆瓣接口地址 url = "https://movie.douban.com/j/chart/top_list" # 遍历6大电影类型接口编号 movie_type_list = [ ("剧情", 11), ("爱情", 13), ("喜剧", 24), ("动作", 5), ("科幻", 17), ("悬疑", 10) ] # 爬取每种类型、统计2025/2024数量 for type_name, type_id in movie_type_list: # 请求参数 params = { "type": type_id, "interval_id": "100:90", "start": 0, "limit": 20 } # 发送请求 res = requests.get(url, headers=headers, params=params) movie_list = res.json() # 遍历电影，按年份统计 for movie in movie_list: date = movie["release_date"] if "2025" in date: type_2025[type_name] += 1 elif "2024" in date: type_2024[type_name] += 1 # 准备绘图数据 labels = list(type_2025.keys()) num25 = list(type_2025.values()) num24 = list(type_2024.values()) # 绘制双柱状图对比 x = range(len(labels)) width = 0.35 plt.figure(figsize=(10, 6)) plt.bar([i - width/2 for i in x], num25, width, label="2025年", color="#6699cc") plt.bar([i + width/2 for i in x], num24, width, label="2024年", color="#ee9999") plt.xlabel("电影类型") plt.ylabel("电影数量") plt.title("豆瓣2025与2024年电影类型数量对比") plt.xticks(x, labels) plt.legend() plt.grid(axis="y", alpha=0.3) plt.show() # 控制台打印统计结果 print("=====2025年各类型电影数量=====") for k, v in type_2025.items(): print(f"{k}：{v} 部") print("\n=====2024年各类型电影数量=====") for k, v in type_2024.items(): print(f"{k}：{v} 部")
2025010115 康静茹
创新小企业创办过程(分类）
# 申报流程基类 class BaseApplyProcess: def __init__(self): # 存储申报数据：[{环节, 属地层级, 主管部门, 办事内容}] self.process_data = [] # 遍历打印全流程 def show_all_process(self): if not self.process_data: print("暂无申报流程数据") return print("=" * 60) for idx, item in enumerate(self.process_data, 1): print(f"流程{idx}：") print(f" 办理环节：{item['环节']}") print(f" 属地层级：{item['属地层级']}") print(f" 主管部门：{item['主管部门']}") print(f" 办事内容：{item['办事内容']}") print("-" * 60) # 根据环节名称查询流程 def search_by_link(self, link_name): res = [d for d in self.process_data if link_name in d["环节"]] if not res: print(f"未查询到【{link_name}】相关流程") return print(f"\n==== 检索结果：{link_name} ====") for item in res: print(f"属地层级：{item['属地层级']}，主管部门：{item['主管部门']}") print(f"办事内容：{item['办事内容']}\n") # 1. 第一类：企业设立申报 class CompanySetUpApply(BaseApplyProcess): def __init__(self): super().__init__() self.init_data() def init_data(self): # 字典存入流程信息 self.process_data = [ { "环节": "名称预先核准", "属地层级": "区级政务服务中心", "主管部门": "市场监督管理局", "办事内容": "审核企业名称，发放名称核准通知书" }, { "环节": "工商营业执照办理", "属地层级": "区级政务服务中心", "主管部门": "市场监督管理局", "办事内容": "提交注册材料，申领营业执照" }, { "环节": "税务登记备案", "属地层级": "区级税务局", "主管部门": "税务部门", "办事内容": "完成税种核定、税务信息录入" } ] # 2. 第二类：创新项目申报 class InnovationProjectApply(BaseApplyProcess): def __init__(self): super().__init__() self.init_data() def init_data(self): self.process_data = [ { "环节": "项目材料提交", "属地层级": "街道/园区管委会", "主管部门": "产业发展科", "办事内容": "上交创新项目申报书、可行性报告" }, { "环节": "初审核查", "属地层级": "区级工信局", "主管部门": "工业和信息化局", "办事内容": "审核项目真实性、创新属性" }, { "环节": "终审公示", "属地层级": "市级科技局", "主管部门": "科学技术局", "办事内容": "专家评审，结果公示与立项批复" } ] # 3. 第三类：补贴资金申报 class SubsidyFundApply(BaseApplyProcess): def __init__(self): super().__init__() self.init_data() def init_data(self): self.process_data = [ { "环节": "补贴申请填报", "属地层级": "园区服务窗口", "主管部门": "园区运营部", "办事内容": "填写补贴申请表，附上经营证明材料" }, { "环节": "资金资质审核", "属地层级": "区级财政局", "主管部门": "财政部门", "办事内容": "核查企业资质、补贴标准与金额" }, { "环节": "资金拨付", "属地层级": "市级财政局", "主管部门": "财政资金科", "办事内容": "审批完成，发放扶持补贴资金" } ] # 4. 第四类：经营备案申报 class BusinessRecordApply(BaseApplyProcess): def __init__(self): super().__init__() self.init_data() def init_data(self): self.process_data = [ { "环节": "经营范围变更备案", "属地层级": "区级政务服务中心", "主管部门": "市场监督管理局", "办事内容": "提交变更申请，更新企业经营信息" }, { "环节": "年度经营报备", "属地层级": "街道营商办", "主管部门": "营商环境服务部门", "办事内容": "上报年度经营数据、企业运营情况" } ] # 主程序运行测试 if __name__ == "__main__": # 实例化各类申报流程 setup_apply = CompanySetUpApply() project_apply = InnovationProjectApply() subsidy_apply = SubsidyFundApply() record_apply = BusinessRecordApply() # 1. 遍历查看全部流程 print("【一、企业设立申报 全流程】") setup_apply.show_all_process() print("【二、创新项目申报 全流程】") project_apply.show_all_process() # 2. 按环节查询 print("\n==== 执行查询操作 ====") project_apply.search_by_link("初审核查") subsidy_apply.search_by_link("资金拨付")
2025010117 李欣栎
博客类
# 用户类 class User: def __init__(self, name, identity): self.name = name # 用户名 self.identity = identity #身份 # 发帖：游客不能发帖 def create_post(self, text): if self.identity == "visitor": print(f"{self.name}【游客】没有发帖权限！") else: new_post = Post(self, text) print(f"{self.name}发布帖子：{text}") return new_post # 帖子类： class Post: def __init__(self, author, content): self.author = author #发帖人 self.content = content #帖子内容 self.like_count = 0 #点赞数量 self.comment_list = [] #评论列表 # 点赞：所有人都能点赞 def add_like(self, user): self.like_count += 1 print(f"{user.name}点赞，当前点赞数：{self.like_count}") # 评论：游客不能评论 def add_comment(self, user, msg): if user.identity == "visitor": print(f"{user.name}【游客】无法发表评论") else: self.comment_list.append([user.name, msg]) print(f"{user.name}评论：{msg}") # ----------------测试代码---------------- if __name__ == "__main__": # 创建三种角色 admin = User("站长", "admin") #管理员 normal_user = User("小李", "user") #普通用户 visitor = User("路人", "visitor") #游客 #管理员发帖 post1 = admin.create_post("Python学习小技巧") #普通用户操作：点赞+评论 post1.add_like(normal_user) post1.add_comment(normal_user, "内容很实用！") #游客操作：点赞可以，评论被限制 post1.add_like(visitor) post1.add_comment(visitor, "随便看看")
2025010118 陈影
电影的制作
# 定义一个电影类 class Movie: def __init__(self, title): self.title = title # 电影名字 #导演 def director(self, name): print(name, "：总指挥，说怎么拍、怎么演的") #编剧 def screenwriter(self, name): print(name, "：写故事、写剧本、写台词") #摄影 def cinematographer(self, name): print(name, "：负责摄像机、拍画面、找角度") #灯光 def lighting(self, name): print(name, "：打光，让画面好看") #录音 def sound(self, name): print(name, "：收声音、录剧本") #场景 def art(self, name): print(name, "：布置场景、衣服、道具") #演员 def actor(self, name): print(name, "：按照剧本演戏、表演角色") #剪辑 def editor(self, name): print(name, "：把拍好的片段剪成完整电影") #制片人 def producer(self, name): print(name, "：管钱、管人、管整个项目") # 开始拍电影 film = Movie("我的青春") print("电影《" + film.title + "》剧组") film.director("张导") film.screenwriter("小王") film.cinematographer("老赵") film.lighting("小陈") film.sound("小刘") film.art("老吴") film.actor("小李") film.editor("小孙") film.producer("王总")
2025010119 淡郑雪
音乐播放同时动态展示频谱图
import numpy as np from scipy.fft import fft import matplotlib.pyplot as plt from matplotlib.animation import FuncAnimation import librosa import os import subprocess # 配置参数 WIDTH, HEIGHT = 800, 500 BAR_COUNT = 64 FPS = 60 MUSIC_PATH = "test.mp3" # 加载MP3音频数据 audio_data, sample_rate = librosa.load(MUSIC_PATH, sr=None) chunk_size = len(audio_data) // (FPS * 8) current_pos = 0 # Windows系统播放器播放音乐 if os.name == "nt": subprocess.Popen(["start", MUSIC_PATH], shell=True) # 初始化画布与柱状图 fig, ax = plt.subplots(figsize=(10, 6)) freq_x = np.linspace(0, sample_rate / 2, BAR_COUNT) bars = ax.bar(freq_x, np.zeros(BAR_COUNT), width=freq_x[1] - freq_x[0], color="#21a6ff") ax.set_title("音乐动态频谱", fontsize=14) ax.set_xlabel("频率 Hz") ax.set_ylabel("振幅") ax.set_xlim(0, sample_rate // 2) ax.set_ylim(0, 1.0) ax.grid(alpha=0.2) # 频谱实时更新函数 def update_frame(frame): global current_pos # 播放到末尾就循环从头播放 if current_pos + chunk_size > len(audio_data): current_pos = 0 chunk = audio_data[current_pos:current_pos + chunk_size] current_pos += chunk_size # 完整闭合括号，不会再报语法错误 fft_vals = np.abs(fft(chunk))[:chunk_size // 2] freq_points = np.fft.rfftfreq(chunk_size, 1 / sample_rate) edges = np.linspace(0, sample_rate/2, BAR_COUNT + 1) heights = np.zeros(BAR_COUNT) for idx in range(BAR_COUNT): mask = (freq_points >= edges[idx]) & (freq_points < edges[idx+1]) if np.any(mask): heights[idx] = np.mean(fft_vals[mask]) # 归一化高度 max_h = np.max(heights) if max_h > 0: heights = heights / max_h * 1.6 for bar, h in zip(bars, heights): bar.set_height(h) return bars # 启动动态动画 def timer_callback(): update_frame(None) fig.canvas.draw() timer = fig.canvas.new_timer(interval=int(1000/FPS)) timer.add_callback(timer_callback) timer.start() plt.show()
2025010121郑舒萍
制作一个知识图
import networkx as nx import matplotlib.pyplot as plt # 先解决中文显示，不用额外参数 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False G = nx.DiGraph() # 详细的动物知识三元组 triple_data = [ ("老虎", "属于", "猫科动物"), ("猫科动物", "属于", "哺乳类"), ("哺乳类", "属于", "脊椎动物"), ("老虎", "栖息地", "东北森林"), ("老虎", "捕食", "鹿科动物"), ("老虎", "分布区域", "东北亚"), ("狮子", "属于", "猫科动物"), ("狮子", "栖息地", "热带草原"), ("狮子", "捕食", "羚羊"), ("鹿科动物", "食性", "植食性"), ("羚羊", "食性", "植食性"), ("东北森林", "气候类型", "温带季风气候"), ("热带草原", "气候类型", "热带草原气候") ] for head, rel, tail in triple_data: G.add_node(head) G.add_node(tail) G.add_edge(head, tail, relation=rel) plt.figure(figsize=(12, 9), dpi=120) pos = nx.spring_layout(G, seed=10, k=0.6) # 简化绘图参数，去掉版本不兼容的font_family nx.draw_networkx_nodes(G, pos, node_size=2500, node_color="#4ECDC4", alpha=0.9) nx.draw_networkx_edges(G, pos, edgelist=G.edges, arrowstyle='->', arrowsize=18, edge_color="#555555") nx.draw_networkx_labels(G, pos, font_size=10, font_weight='bold') edge_labels = nx.get_edge_attributes(G, 'relation') # 关系标签用红色是我特意区分的，不想红可以改成"#333333" nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=8, font_color="#FF6B6B") plt.title("动物领域详细知识图谱", fontsize=14, pad=20) plt.axis('off') plt.tight_layout() plt.show()
2025010124 胡鑫
凸透镜实验
import networkx as nx
import matplotlib.pyplot as plt
# 先解决中文显示，不用额外参数
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
G = nx.DiGraph()
# 详细的动物知识三元组
triple_data = [
("老虎", "属于", "猫科动物"),
("猫科动物", "属于", "哺乳类"),
("哺乳类", "属于", "脊椎动物"),
("老虎", "栖息地", "东北森林"),
("老虎", "捕食", "鹿科动物"),
("老虎", "分布区域", "东北亚"),
("狮子", "属于", "猫科动物"),
("狮子", "栖息地", "热带草原"),
("狮子", "捕食", "羚羊"),
("鹿科动物", "食性", "植食性"),
("羚羊", "食性", "植食性"),
("东北森林", "气候类型", "温带季风气候"),
("热带草原", "气候类型", "热带草原气候")
]
for head, rel, tail in triple_data:
G.add_node(head)
G.add_node(tail)
G.add_edge(head, tail, relation=rel)
plt.figure(figsize=(12, 9), dpi=120)
pos = nx.spring_layout(G, seed=10, k=0.6)
# 简化绘图参数，去掉版本不兼容的font_family
nx.draw_networkx_nodes(G, pos, node_size=2500, node_color="#4ECDC4", alpha=0.9)
nx.draw_networkx_edges(G, pos, edgelist=G.edges, arrowstyle='->', arrowsize=18, edge_color="#555555")
nx.draw_networkx_labels(G, pos, font_size=10, font_weight='bold')
edge_labels = nx.get_edge_attributes(G, 'relation')
# 关系标签用红色是我特意区分的，不想红可以改成"#333333"
nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=8, font_color="#FF6B6B")
plt.title("动物领域详细知识图谱", fontsize=14, pad=20)
plt.axis('off')
plt.tight_layout()
plt.show()
import matplotlib.pyplot as plt # 凸透镜成像公式 1/u + 1/v = 1/f def calculate_image(object_dist, focal_len): if object_dist == focal_len: return None, None image_dist = (object_dist * focal_len) / (object_dist - focal_len) magnify = image_dist / object_dist return image_dist, magnify # 可调参数 f = 120 # 焦距 u = 220 # 物距 obj_h = 80 # 物体高度 v, scale = calculate_image(u, f) fig, ax = plt.subplots(figsize=(10, 4)) # 主光轴 ax.axhline(y=0, color="gray", linewidth=2) # 凸透镜 ax.axvline(x=0, color="blue", linewidth=3) # 左右焦点 ax.scatter([-f, f], [0, 0], c="green", s=60) ax.text(-f, -10, "F", fontsize=12) ax.text(f, -10, "F", fontsize=12) # 绘制实物（红色） obj_x_pos = -u ax.plot([obj_x_pos, obj_x_pos], [0, obj_h], c="red", lw=3, label="蜡烛(物体)") # 绘制像 if v is not None: img_x_pos = v img_h = scale * obj_h if v > 0: # 实像：倒立实线 ax.plot([img_x_pos, img_x_pos], [0, img_h], c="#990099", lw=3, label="实像") else: # 虚像：正立虚线 ax.plot([img_x_pos, img_x_pos], [0, img_h], c="#990099", lw=2, ls="--", label="虚像") ax.set_xlim(-400, 400) ax.set_ylim(-130, 130) ax.set_xlabel("距离") ax.set_ylabel("高度") ax.grid(alpha=0.3) ax.legend() plt.title("凸透镜成像物理仿真") plt.show()
2025010125 刘芮孜
奖学金申请流程
class Student: """学生类：发起奖学金申请、提交材料""" def __init__(self, name, student_id, gpa, has_discipline=False): self.name = name # 姓名 self.student_id = student_id # 学号 self.gpa = gpa # 绩点 self.has_discipline = has_discipline # 是否违纪 self.application_form = None # 申请表 self.apply_status = "未提交" def fill_application(self, scholarship_type): """填写申请表""" self.application_form = { "student_name": self.name, "student_id": self.student_id, "gpa": self.gpa, "scholarship": scholarship_type, "discipline_record": self.has_discipline } print(f"【学生{self.name}】完成{scholarship_type}奖学金申请表填写") def submit_to_counselor(self, counselor): """把材料提交给辅导员""" if self.application_form is None: print("错误：还未填写申请表，无法提交！") return # 提交给辅导员审核 counselor.receive_application(self.application_form, self) self.apply_status = "已提交辅导员" class Counselor: """辅导员类：初审学生材料、筛选资格、上报院系""" def __init__(self, counselor_name, class_range): self.name = counselor_name self.manage_classes = class_range # 管辖班级 self.passed_apps = [] # 初审通过名单 self.reject_apps = [] # 初审驳回名单 def receive_application(self, form, student): """接收学生申请并初审""" print(f"\n【辅导员{self.name}】收到学生{student.name}的申请，开始初审") # 初审规则：无违纪 + 绩点达标(示例阈值3.0) if form["discipline_record"] is True: result = "驳回（存在违纪记录）" self.reject_apps.append(form) elif form["gpa"] < 3.0: result = "驳回（绩点未达3.0门槛）" self.reject_apps.append(form) else: result = "初审通过" self.passed_apps.append(form) print(f"【辅导员{self.name}】{student.name} 初审结果：{result}") def report_to_department(self, dept_leader): """初审通过名单上报给院系领导""" if len(self.passed_apps) == 0: print(f"\n【辅导员{self.name}】无初审通过申请，无需上报院系") return print(f"\n【辅导员{self.name}】向院系领导上报{len(self.passed_apps)}份初审通过申请") dept_leader.receive_counselor_list(self.passed_apps, self) class DepartmentLeader: """院系领导类：复审、院内排序、上报校奖助办""" def __init__(self, dept_name, leader_name): self.dept = dept_name self.name = leader_name self.dept_passed = [] self.dept_reject = [] def receive_counselor_list(self, app_list, counselor): """接收辅导员上报的名单，院系复审""" print(f"\n【院系{self.dept}领导{self.name}】收到辅导员{counselor.name}上报材料，复审中") # 院系复审：院内绩点二次校验，筛选top名额（示例只留绩点前2名） sorted_apps = sorted(app_list, key=lambda x: x["gpa"], reverse=True) quota = 2 # 院系分配名额2个 self.dept_passed = sorted_apps[:quota] self.dept_reject = sorted_apps[quota:] print(f"【院系{self.dept}】复审通过{len(self.dept_passed)}人，驳回{len(self.dept_reject)}人") def report_to_school_office(self, school_office): """把院内终审名单上报学校奖学金办公室""" if len(self.dept_passed) == 0: print(f"\n【院系{self.dept}】无通过名单，不上报学校") return print(f"\n【院系{self.dept}】向校奖助办上报{len(self.dept_passed)}名候选人") school_office.receive_dept_list(self.dept_passed, self) class SchoolScholarshipOffice: """校奖学金办公室：全校终审、公示、发放通知""" def __init__(self): self.final_award_list = [] def receive_dept_list(self, dept_list, dept_leader): """接收各院系上报名单，全校最终审核""" print(f"\n【校奖助办】收到{dept_leader.dept}上报名单，全校终审校验") # 全校终审：合规性复核，全部院内上报合规则全部录取 self.final_award_list.extend(dept_list) def publish_result(self): """公示最终获奖名单""" print("\n==========全校奖学金最终公示名单==========") if len(self.final_award_list) == 0: print("无获奖学生") return for idx, info in enumerate(self.final_award_list, 1): print(f"{idx}. 姓名：{info['student_name']} | 学号：{info['student_id']} | 绩点：{info['gpa']} | 奖项：{info['scholarship']}") print("==========================================") # ---------------------- 测试运行流程 ---------------------- if __name__ == "__main__": # 1. 创建角色实例 student1 = Student("张三", "2026001", gpa=3.8) student2 = Student("李四", "2026002", gpa=2.9) # 绩点不够 student3 = Student("王五", "2026003", gpa=3.9, has_discipline=True) # 违纪 student4 = Student("赵六", "2026004", gpa=4.0) counselor1 = Counselor("王辅导员", ["计科1班", "计科2班"]) dept_head = DepartmentLeader("计算机学院", "李院长") school_office = SchoolScholarshipOffice() # 2. 学生填写并提交申请 student1.fill_application("校级一等奖学金") student1.submit_to_counselor(counselor1) student2.fill_application("校级一等奖学金") student2.submit_to_counselor(counselor1) student3.fill_application("校级一等奖学金") student3.submit_to_counselor(counselor1) student4.fill_application("校级一等奖学金") student4.submit_to_counselor(counselor1) # 3. 辅导员上报院系 counselor1.report_to_department(dept_head) # 4. 院系上报学校 dept_head.report_to_school_office(school_office) # 5. 学校公示结果 school_office.publish_result()
2025010127 刘杨龙
import cv2 import time # 打开摄像头 cap = cv2.VideoCapture(0) # 设置帧率 fps = 20 # 视频编码格式 fourcc = cv2.VideoWriter_fourcc(*'mp4v') width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) out = cv2.VideoWriter('record_1s.mp4', fourcc, fps, (width, height)) start_time = time.time() # 录制1秒钟 while time.time() - start_time < 1: ret, frame = cap.read() if not ret: break out.write(frame) cv2.imshow('recording', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break # 释放资源 cap.release() out.release() cv2.destroyAllWindows() print("1秒视频录制完成，保存为 record_1s.mp4")
2025010128 贾姝慧
包的形式
# 从对应包(文件)导入各个类 from restaurant.customer import Customer from restaurant.waiter import Waiter from restaurant.cook import Cook from restaurant.cashier import Cashier if __name__ == "__main__": # 1.实例化所有角色 zhangsan = Customer("张三") xiaoming = Waiter("小明") laowang = Cook("老王") xiaohong = Cashier("小红") # 2.按照业务顺序执行流程（和截图运行输出完全一致） xiaoming.lead_seat() # 小明引导入座 xiaoming.send_menu() # 小明递菜单 zhangsan.order_food() # 张三点餐 xiaoming.tell_cook() # 小明告诉厨师菜谱 laowang.cook_food() # 老王做菜 zhangsan.eat() # 张三用餐 xiaohong.count_cost() # 小红计算餐费 zhangsan.pay_money() # 张三支付餐费 xiaohong.get_money() # 小红收取餐费 print("进程已结束，退出代码为 0")
2025010130任鸿杰
平抛
import numpy as np import matplotlib.pyplot as plt from matplotlib.animation import FuncAnimation # ========== 物理参数 ========== g = 9.8 # 重力加速度 m/s² v0 = 10 # 水平初速度 h0 = 15 # 初始高度 dt = 0.03 # 时间步长 ground_y = 0 # 地面高度 # 存储数据 t_arr = [] x_arr = [] y_arr = [] t = 0 x = 0 y = h0 running = True # 落地开关 # 画布设置 fig, ax = plt.subplots(figsize=(10, 6)) ax.set_xlim(-2, 35) ax.set_ylim(-2, h0 + 3) ax.set_xlabel("水平位置 X (m)", fontsize=12) ax.set_ylabel("竖直位置 Y (m)", fontsize=12) ax.set_title("平抛运动物理模拟（触地停止）", fontsize=14) ax.grid(alpha=0.3) # 画地面 ax.axhline(y=ground_y, c="k", lw=3, label="地面") ax.legend() # 轨迹线、小球、文字 trace, = ax.plot([], [], "r-", lw=2) ball, = ax.plot([], [], "o", color="darkblue", markersize=10) text_info = ax.text(20, h0, "", fontsize=11) def init(): trace.set_data([], []) ball.set_data([], []) text_info.set_text("") return trace, ball, text_info def update(frame): global t, x, y, running if not running: return trace, ball, text_info # 平抛公式 x = v0 * t y = h0 - 0.5 * g * t ** 2 # 落地判定 if y <= ground_y: y = ground_y running = False t_arr.append(t) x_arr.append(x) y_arr.append(y) trace.set_data(x_arr, y_arr) ball.set_data(x, y) text_info.set_text(f"t={t:.2f}s X={x:.2f}m Y={y:.2f}m") t += dt return trace, ball, text_info # 动画 ani = FuncAnimation( fig, update, init_func=init, interval=25, blit=True, cache_frame_data=False ) plt.show()
2025010131 董玥卓
爬取股票分析最近三个月产业最高的
import akshare as ak import pandas as pd import matplotlib.pyplot as plt from datetime import datetime, timedelta import warnings warnings.filterwarnings("ignore") # ===================== 1. 配置参数 ===================== today = datetime.now() start_date = (today - timedelta(days=90)).strftime("%Y%m%d") end_date = today.strftime("%Y%m%d") # 解决matplotlib中文乱码 plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"] plt.rcParams["axes.unicode_minus"] = False # ===================== 2. 爬取行业板块数据 ===================== def get_industry_board_data(): board_df = ak.stock_board_industry_name_ths() print(f"共获取到 {len(board_df)} 个行业板块") print("-" * 60) result_list = [] for idx, row in board_df.iterrows(): if idx >= 30: break board_name = row["name"] try: hist_df = ak.stock_board_industry_hist_ths( symbol=board_name, start_date=start_date, end_date=end_date ) if len(hist_df) < 2: print(f"{board_name} 行情数据不足，跳过") continue start_close = hist_df.iloc[0]["收盘"] end_close = hist_df.iloc[-1]["收盘"] change_rate = round((end_close - start_close) / start_close * 100, 2) result_list.append({ "行业板块": board_name, "近三月涨跌幅(%)": change_rate }) print(f"成功统计：{board_name} | 涨跌幅：{change_rate}%") except Exception as e: # 打印异常信息，方便定位问题 print(f"{board_name} 获取失败，错误：{str(e)}") continue # 关键修复：先判断列表是否为空，再转DataFrame if not result_list: print("警告：没有采集到任何板块数据！") return pd.DataFrame() result_df = pd.DataFrame(result_list) # 此时一定存在"近三月涨跌幅(%)"列，不会报KeyError result_df = result_df.sort_values(by="近三月涨跌幅(%)", ascending=False) return result_df # ===================== 3. 数据分析与可视化 ===================== def analysis_and_show(df): print("\n" + "=" * 60) print("【近三个月 A股行业板块涨幅排名】") print("=" * 60) print(df.reset_index(drop=True)) top1_board = df.iloc[0] print(f"\n🔥 近三个月涨幅最高产业：{top1_board['行业板块']}") print(f"📈 累计涨幅：{top1_board['近三月涨跌幅(%)']}%") show_df = df.head(15) plt.figure(figsize=(14, 7)) bars = plt.bar(show_df["行业板块"], show_df["近三月涨跌幅(%)"], color="#2E86AB") plt.xticks(rotation=45, ha="right") plt.title("近三个月 A股行业板块涨幅TOP15", fontsize=16) plt.ylabel("涨跌幅（%）", fontsize=12) plt.tight_layout() for bar in bars: height = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2., height + 0.2, f"{height}%", ha="center", va="bottom", fontsize=8) plt.show() # ===================== 4. 主程序入口 ===================== if __name__ == "__main__": board_data = get_industry_board_data() if not board_data.empty: analysis_and_show(board_data) else: print("未获取到有效板块数据，请检查网络或稍后重试！")
2025010132 李佳雨
表格
# 影视数据列表 movie_data = [ ["这个杀手不太冷", "1994-09-14", 9.4, 23380290], ["指环王3：王者无敌", "2004-03-12", 9.3, 841200], ["蝙蝠侠：黑暗骑士", "2008-07-14", 9.2, 1109782], ["指环王2：双塔奇兵", "2003-04-25", 9.2, 790030], ["七武士", "1954-04-26", 9.3, 209034], ["指环王1：护戒使者", "2002-04-04", 9.1, 886684], ["黑客帝国", "2000-01-14", 9.1, 874612], ["让子弹飞", "2010-12-16", 9.0, 1776981], ["进击的巨人 最终季 完结篇 前篇", "2023-03-04", 9.5, 83446], ["搏击俱乐部", "1999-09-10", 9.0, 887367], ["杀人回忆", "2003-05-02", 8.9, 758809], ["蝙蝠侠：黑暗骑士崛起", "2012-08-27", 8.9, 756256], ["勇敢的心", "1995-05-18", 8.9, 575177], ["攻壳机动队", "1995-11-18", 9.1, 147229], ["功夫", "2004-12-23", 8.8, 1205200], ["阿凡达", "2010-01-04", 8.8, 1477081], ["进击的巨人 最终季 完结篇 后篇", "2023-11-04", 9.3, 80042], ["加勒比海盗", "2003-11-21", 8.8, 898682], ["纵横四海", "1991-02-02", 8.8, 444795], ["被解救的姜戈", "2013-05-12", 8.8, 638003] ] # 表头 header = ["电影名称", "出品时间", "分值", "评价人数"] # 格式化打印表格 print(f"{'='*95}") print(f"{'电影名称':<30}{'出品时间':<12}{'分值':<6}{'评价人数':<10}") print(f"{'='*95}") for name, date, score, num in movie_data: print(f"{name:<30}{date:<12}{score:<6}{num:<10}") print(f"{'='*95}")
浙公网安备 33010602011771号