25级第七次实验报告
| 2025010089 | 1 |
| 2025010090 | |
| 2025010091 | 1 |
| 2025010092 | 1 |
| 2025010093 | 1 |
| 2025010094 | |
| 2025010095 | 1 |
| 2025010096 | |
| 2025010097 | |
| 2025010098 | 1 |
| 2025010099 | 1 |
| 2025010100 | |
| 2025010101 | 1 |
| 2025010102 |
1 |
| 2025010103 | |
| 2025010104 | |
| 2025010105 | |
| 2025010106 | |
| 2025010107 |
1 |
| 2025010108 | |
| 2025010109 | |
| 2025010110 | |
| 2025010112 | |
| 2025010113 | 1 |
| 2025010114 | |
| 2025010115 | 1 |
| 2025010117 | 1 |
| 2025010118 | 1 |
| 2025010119 | 1 |
| 2025010120 | |
| 2025010121 | |
| 2025010122 | |
| 2025010124 | 1 |
| 2025010125 | 1 |
| 2025010126 | |
| 2025010127 | |
| 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()
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()
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}")
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()
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()
2025010124 胡鑫
凸透镜实验
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号