CourseComparator 0.1.0__tar.gz

coursecomparator-0.1.0/CourseComparator/__init__.py

@@ -0,0 +1,33 @@
+"""
+课程比较器模块
+
+该模块提供了课程比较和课程集合操作的功能，用于比较不同专业、不同年份的课程设置，
+帮助用户了解课程变化，包括可冲抵、待确认、需补修和需放弃的课程。
+
+主要组件：
+- Course: 课程类，表示一门课程的基本信息
+- CoursePair: 课程对类，表示两个课程之间的关系
+- CourseSet: 课程集合类，表示一组课程
+- CourseSetDelta: 课程集合差异类，表示两个课程集合之间的差异
+- init: 创建课程数据加载器的函数
+"""
+
+from .cc_classes import (
+    Course,
+    CoursePair,
+    CourseSet,
+    CourseSetDelta,
+)
+
+from .cc_functions import init, EMPTY_SEMESTER
+
+__all__ = [
+    "Course",
+    "CoursePair",
+    "CourseSet",
+    "CourseSetDelta",
+    "init",
+    "EMPTY_SEMESTER",
+]
+
+__version__ = "0.1.0"

coursecomparator-0.1.0/CourseComparator/cc_classes.py

@@ -0,0 +1,411 @@
+from typing import List, Optional
+
+
+class Course:
+    """
+    课程类
+
+    表示一门课程的基本信息，包括课程代码、课程名称、学分和是否必修
+    """
+
+    def __init__(
+        self, course_code: str, course_name: str, credit: float, required: bool
+    ):
+        """
+        初始化课程对象
+
+        Args:
+            course_code: 课程代码
+            course_name: 课程名称
+            credit: 课程学分
+            required: 是否为必修课
+        """
+        self.course_code = course_code
+        self.course_name = course_name
+        self.credit = credit
+        self.required = required
+
+    def __repr__(self) -> str:
+        """
+        返回课程对象的字符串表示，用于调试
+
+        Returns:
+            str: 课程对象的字典表示
+        """
+        return str(
+            {
+                "course_code": self.course_code,
+                "course_name": self.course_name,
+                "credit": self.credit,
+                "required": self.required,
+            }
+        )
+
+    def __str__(self) -> str:
+        """
+        返回课程对象的字符串表示，用于显示
+
+        Returns:
+            str: 格式化的课程信息字符串
+        """
+        return f"{self.course_code}\t{self.course_name}\t{self.credit} 学分\t{'必修' if self.required else '选修'}"
+
+    def __eq__(self, other: "Course") -> bool:
+        """
+        判断两个课程是否相等
+
+        Args:
+            other: 另一个课程
+
+        Returns:
+            bool: 如果两个课程的所有属性都相同，则返回True，否则返回False
+        """
+        if not isinstance(other, Course):
+            return False
+        return (
+            self.course_code == other.course_code
+            and self.course_name == other.course_name
+            and self.credit == other.credit
+            and self.required == other.required
+        )
+
+    def __gt__(self, other: "Course") -> bool:
+        """
+        判断当前课程是否可以完全涵盖另一个不同的课程(即虽不同但也可冲抵的情况)
+
+        1. 两个课程不完全相同
+        2. 课程代码相同
+        3. 课程名称相同
+        4. 当前课程(旧的)学分大于等于另一个课程(新的)
+        5. 如果当前课程(旧的)是选修，另一个课程(新的)不能是必修
+
+        Args:
+            other: 另一个课程
+
+        Returns:
+            bool: 如果当前课程可以完全涵盖另一个不同的课程，则返回True，否则返回False
+        """
+        if not isinstance(other, Course):
+            return False
+        # 不能完全一致
+        if self == other:
+            return False
+        # 课程代码必须相同
+        if self.course_code != other.course_code:
+            return False
+        # 课程名必须相同
+        if self.course_name != other.course_name:
+            return False
+        # 当前课程学分必须大于等于另一个课程
+        if self.credit > other.credit:
+            return False
+        # 选修不能转必修
+        if not self.required and other.required:
+            return False
+        return True
+
+
+class CoursePair:
+    """
+    课程对类
+
+    表示新旧两门课程的对比，用于显示课程变化
+    """
+
+    def __init__(self, old_course: Course, new_course: Course):
+        """
+        初始化课程对对象
+
+        Args:
+            old_course: 旧课程
+            new_course: 新课程
+        """
+        self.old_course = old_course
+        self.new_course = new_course
+
+    def __repr__(self) -> str:
+        """
+        返回课程对对象的字符串表示，用于调试
+
+        Returns:
+            str: 课程对对象的字典表示
+        """
+        return str(
+            {
+                "old": {
+                    "course_code": self.old_course.course_code,
+                    "course_name": self.old_course.course_name,
+                    "credit": self.old_course.credit,
+                    "required": self.old_course.required,
+                },
+                "new": {
+                    "course_code": self.new_course.course_code,
+                    "course_name": self.new_course.course_name,
+                    "credit": self.new_course.credit,
+                    "required": self.new_course.required,
+                },
+            }
+        )
+
+    def __str__(self) -> str:
+        """
+        返回课程对对象的字符串表示，用于显示
+
+        显示新旧课程的对比，包括课程代码、课程名称、学分和是否必修
+        如果某项属性发生变化，会添加标记：
+        - [ ! ]: 表示课程代码或课程名称变化
+        - [ + ]: 表示学分增加或从选修变为必修
+        - [ - ]: 表示学分减少或从必修变为选修
+
+        Returns:
+            str: 格式化的课程对比字符串
+        """
+        # 准备标记
+        code_mark = (
+            " [ ! ]"
+            if self.old_course.course_code != self.new_course.course_code
+            else ""
+        )
+        name_mark = (
+            " [ ! ]"
+            if self.old_course.course_name != self.new_course.course_name
+            else ""
+        )
+
+        # 学分标记
+        credit_mark = ""
+        if self.old_course.credit != self.new_course.credit:
+            credit_mark = (
+                " [ + ]"
+                if self.new_course.credit > self.old_course.credit
+                else " [ - ]"
+            )
+
+        # 选必修标记
+        required_mark = ""
+        if self.old_course.required != self.new_course.required:
+            required_mark = " [ + ]" if self.new_course.required else " [ - ]"
+
+        # 计算各项最大宽度
+        max_code_width = max(
+            len(self.old_course.course_code),
+            len(self.new_course.course_code) + len(code_mark),
+        )
+        max_name_width = max(
+            len(self.old_course.course_name),
+            len(self.new_course.course_name) + len(name_mark),
+        )
+        max_credit_width = max(
+            len(f"{self.old_course.credit} 学分"),
+            len(f"{self.new_course.credit} 学分") + len(credit_mark),
+        )
+        max_required_width = max(len("必修"), len("选修") + len(required_mark))
+
+        # 构建格式化字符串
+        format_str = f"{{prefix}}  {{code:<{max_code_width}}}\t{{name:<{max_name_width}}}\t{{credit:<{max_credit_width}}}\t{{required:<{max_required_width}}}"
+
+        # 构建两行输出
+        old_line = format_str.format(
+            prefix="OLD:",
+            code=self.old_course.course_code,
+            name=self.old_course.course_name,
+            credit=f"{self.old_course.credit} 学分",
+            required="必修" if self.old_course.required else "选修",
+        )
+
+        new_line = format_str.format(
+            prefix="NEW:",
+            code=f"{self.new_course.course_code}{code_mark}",
+            name=f"{self.new_course.course_name}{name_mark}",
+            credit=f"{self.new_course.credit} 学分{credit_mark}",
+            required=f"{'必修' if self.new_course.required else '选修'}{required_mark}",
+        )
+
+        return f"{old_line}\n{new_line}"
+
+
+class CourseSet:
+    """
+    课程集合类
+
+    表示一组课程，提供课程集合的操作方法
+    """
+
+    def __init__(self, courses: Optional[List[Course]] = None):
+        """
+        初始化课程集合对象
+
+        Args:
+            courses: 课程列表，默认为None（空列表）
+        """
+        self.courses = courses or []
+        self._validate_courses()
+
+    def _validate_courses(self) -> None:
+        """
+        验证课程集合中是否有重复的课程代码或课程名
+
+        Raises:
+            ValueError: 如果存在重复的课程代码或课程名
+        """
+        code_set = set()
+        name_set = set()
+        for course in self.courses:
+            if course.course_code in code_set:
+                raise ValueError(f"课程代码重复: {course.course_code}")
+            if course.course_name in name_set:
+                raise ValueError(f"课程名重复: {course.course_name}")
+            code_set.add(course.course_code)
+            name_set.add(course.course_name)
+
+    def append(self, course: Course) -> None:
+        """
+        添加单个课程到集合中
+
+        Args:
+            course: 要添加的课程
+
+        Raises:
+            ValueError: 如果课程代码或课程名已存在
+        """
+        if any(c.course_code == course.course_code for c in self.courses):
+            raise ValueError(f"课程代码重复: {course.course_code}")
+        if any(c.course_name == course.course_name for c in self.courses):
+            raise ValueError(f"课程名重复: {course.course_name}")
+        self.courses.append(course)
+
+    def __add__(self, other: "CourseSet") -> "CourseSet":
+        """
+        合并两个课程集合, 用于聚合同一方案的不同学期
+
+        Args:
+            other: 另一个课程集合
+
+        Returns:
+            CourseSet: 合并后的新课程集合
+
+        Raises:
+            TypeError: 如果other不是CourseSet类型
+        """
+        if not isinstance(other, CourseSet):
+            raise TypeError("只能与 CourseSet 类型相加")
+        new_courses = self.courses + other.courses
+        return CourseSet(new_courses)
+
+    def __sub__(self, other: "CourseSet") -> "CourseSetDelta":
+        """
+        用旧的培养方案减去新的培养方案, 用于计算两者之间的差异
+
+        Args:
+            other: 另一个课程集合
+
+        Returns:
+            CourseSetDelta: 表示两个课程集合差异的对象
+
+        Raises:
+            TypeError: 如果other不是CourseSet类型
+        """
+        if not isinstance(other, CourseSet):
+            raise TypeError("只能与 CourseSet 类型相减")
+        return CourseSetDelta(self, other)
+
+    def __str__(self) -> str:
+        """
+        返回课程集合的字符串表示
+
+        Returns:
+            str: 所有课程的字符串表示，每行一个课程
+        """
+        return "\n".join(str(course) for course in self.courses)
+
+
+class CourseSetDelta:
+    """
+    课程集合差异类
+
+    表示两个课程集合之间的差异，包括可冲抵、待确认、需补修和需放弃的课程
+    """
+
+    def __init__(self, old_set: CourseSet, new_set: CourseSet):
+        """
+        初始化课程集合差异对象
+
+        Args:
+            old_set: 旧课程集合
+            new_set: 新课程集合
+        """
+        self.consistent_or_including = []  # 可冲抵
+        self.similar = []  # 待确认
+        self.new_only = []  # 需补修
+        self.old_only = []  # 需放弃
+
+        self._calculate_delta(old_set, new_set)
+
+    def _calculate_delta(self, old_set: CourseSet, new_set: CourseSet) -> None:
+        """
+        计算两个课程集合之间的差异
+
+        Args:
+            old_set: 旧课程集合
+            new_set: 新课程集合
+        """
+        # 处理可冲抵和待确认的课程
+        for old_course in old_set.courses:
+            found = False
+            for new_course in new_set.courses:
+                # 1. 完全相等或可冲抵的情况
+                if old_course == new_course or old_course > new_course:
+                    self.consistent_or_including.append(
+                        CoursePair(old_course, new_course)
+                    )
+                    found = True
+                    break
+                # 2. 课程代码相同或课程名称相同
+                elif (
+                    old_course.course_code == new_course.course_code
+                    or old_course.course_name == new_course.course_name
+                ):
+                    self.similar.append(CoursePair(old_course, new_course))
+                    found = True
+                    break
+            # 3. 未找到匹配的旧课程
+            if not found:
+                self.old_only.append(old_course)
+
+        # 4. 处理需补修的课程
+        for new_course in new_set.courses:
+            if not any(
+                old_course == new_course
+                or old_course > new_course
+                or old_course.course_code == new_course.course_code
+                or old_course.course_name == new_course.course_name
+                for old_course in old_set.courses
+            ):
+                self.new_only.append(new_course)
+
+    def __str__(self) -> str:
+        """
+        返回课程集合差异的字符串表示
+
+        Returns:
+            str: 格式化的课程差异字符串，包括可冲抵、待确认、需补修和需放弃的课程
+        """
+        result = []
+
+        if self.consistent_or_including:
+            result.append("\n【可冲抵】\n")
+            result.extend(str(pair) + "\n" for pair in self.consistent_or_including)
+
+        if self.similar:
+            result.append("\n【待确认】\n")
+            result.extend(str(pair) + "\n" for pair in self.similar)
+
+        if self.new_only:
+            result.append("\n【需补修】\n")
+            result.extend(str(course) + "\n" for course in self.new_only)
+
+        if self.old_only:
+            result.append("\n【需放弃】\n")
+            result.extend(str(course) + "\n" for course in self.old_only)
+
+        return "\n".join(result)

coursecomparator-0.1.0/CourseComparator/cc_functions.py

@@ -0,0 +1,130 @@
+from typing import Callable
+from .cc_classes import Course, CourseSet
+import csv
+import pickle
+from pathlib import Path
+
+
+# 全局唯一的0学期对象，表示刚入学的状态
+EMPTY_SEMESTER = CourseSet()
+
+
+def init(data_dir: str) -> Callable[[str, str, int], CourseSet]:
+    """
+    创建课程数据加载器
+
+    Args:
+        data_dir: 数据目录的路径
+
+    Returns:
+        Callable[[str, str, int], CourseSet]: 加载器函数，接受专业名称、年份和学期作为参数，返回课程集合
+    """
+    # 确保数据目录存在
+    data_path = Path(data_dir)
+    if not data_path.exists():
+        raise FileNotFoundError(f"数据目录不存在: {data_dir}")
+
+    # 创建缓存目录
+    cache_dir = data_path / "__cc_cache__"
+    cache_dir.mkdir(exist_ok=True)
+
+    def loader(major: str, year: str, semester: int) -> CourseSet:
+        """
+        加载指定专业、年份和学期的课程数据
+
+        Args:
+            major: 专业名称
+            year: 年份
+            semester: 学期数（0-8，0表示刚入学的状态）
+
+        Returns:
+            CourseSet: 指定学期的课程集合
+
+        Raises:
+            FileNotFoundError: 如果专业目录不存在
+            ValueError: 如果学期数不在有效范围内
+        """
+        # 处理 0 学期（刚入学的状态）
+        if semester == 0:
+            return EMPTY_SEMESTER
+
+        # 验证学期数
+        if semester < 0 or semester > 8:
+            raise ValueError(f"学期数必须在0-8之间，当前值: {semester}")
+
+        # 构建数据目录路径
+        major_dir = data_path / major / year
+        if not major_dir.exists():
+            raise FileNotFoundError(f"专业目录不存在: {major_dir}")
+
+        # 构建缓存文件路径
+        cache_file = cache_dir / f"{major}_{year}.pkl"
+
+        # 检查缓存是否存在且是最新的
+        if cache_file.exists():
+            # 获取缓存文件的修改时间
+            cache_mtime = cache_file.stat().st_mtime
+
+            # 检查数据文件是否有更新
+            data_files_updated = False
+            for i in range(1, 9):
+                csv_file = major_dir / f"{i}.csv"
+                if csv_file.exists() and csv_file.stat().st_mtime > cache_mtime:
+                    data_files_updated = True
+                    break
+
+            # 如果数据文件没有更新，直接使用缓存
+            if not data_files_updated:
+                with open(cache_file, "rb") as f:
+                    course_sets = pickle.load(f)
+
+                    # 如果学期数大于可用的学期数，返回最后一个学期的课程集合
+                    if semester > len(course_sets):
+                        return course_sets[-1]
+
+                    # 计算前semester个学期的课程集合之和
+                    result = CourseSet()
+                    for i in range(semester):
+                        result = result + course_sets[i]
+
+                    return result
+
+        # 如果没有缓存或缓存已过期，重新加载数据
+        course_sets = []
+        for i in range(1, 9):
+            csv_file = major_dir / f"{i}.csv"
+            if not csv_file.exists():
+                # 如果某个学期的文件不存在，添加一个空的课程集合
+                course_sets.append(CourseSet())
+                continue
+
+            courses = []
+            with open(csv_file, "r", encoding="GBK") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    course = Course(
+                        course_code=row["course_code"],
+                        course_name=row["course_name"],
+                        credit=float(row["credit"]),
+                        required=bool(int(row["required"])),
+                    )
+                    courses.append(course)
+
+            course_sets.append(CourseSet(courses))
+
+        # 保存缓存
+        with open(cache_file, "wb") as f:
+            pickle.dump(course_sets, f)
+
+        # 如果学期数大于可用的学期数，返回最后一个学期的课程集合
+        if semester > len(course_sets):
+            return course_sets[-1]
+
+        # 计算前semester个学期的课程集合之和
+        result = CourseSet()
+        for i in range(semester):
+            result = result + course_sets[i]
+
+        return result
+
+    return loader

coursecomparator-0.1.0/CourseComparator.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: CourseComparator
+Version: 0.1.0
+Summary: 用于比较不同的专业、届别或年级之间的课程设置，供转专业、降级学生确认可冲抵及需补修的课程。
+Author-email: Vincy SHI <vincy@vincy1230.net>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vincy1230/Course-Comparator
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: license-file
+
+# Course-Comparator 课程比较器
+
+用于比较不同的专业、届别或年级之间的课程设置，供转专业、降级学生确认可冲抵及需补修的课程。
+
+## 使用方法
+
+### 整理数据集
+
+将各个课程的数据集按照如下格式整理：
+
+`<数据集根目录>` / `<专业>` / `<届别>` / `<学期>.csv`
+
+例如，人工智能专业 2021 级第 1 ~ 8 学期的课程数据位于，分别存于：
+
+`<数据集根目录>` / `人工智能` / `2021` / `1.csv`
+`<数据集根目录>` / `人工智能` / `2021` / `2.csv`
+...
+`<数据集根目录>` / `人工智能` / `2021` / `8.csv`
+
+csv 文件的格式如下：
+
+| csv 表头    | 含义     | 示例             | 备注                   |
+| ----------- | -------- | ---------------- | ---------------------- |
+| course_code | 课程代码 | `MATA5B1001`     | 将解析为字符串         |
+| course_name | 课程名称 | `高等数学（上）` | 将解析为字符串         |
+| credit      | 课程学分 | `5`              | 将解析为浮点数         |
+| required    | 是否必修 | `1`              | `1` 为必修，`0` 为选修 |
+
+```csv
+course_code,course_name,credit,required
+MATA5B1001,高等数学（上）,5,1
+...
+```
+
+### 安装本软件包
+
+```bash
+pip install CourseComparator
+```
+
+### 运行程序
+
+```python
+# 导入课程比较器模块
+import CourseComparator as cc
+
+# 传入数据集根目录，初始化数据加载器
+loader = cc.init("<数据集根目录>")
+
+# 获取旧的课程方案
+old_courses = loader("<专业>", "<届别>", <学期>)
+
+# 获取新的课程方案
+new_courses = loader("<专业>", "<届别>", <学期>)
+
+# 打印两个方案的差异
+print(old_courses - new_courses)
+```

coursecomparator-0.1.0/CourseComparator.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENCE
+README.md
+pyproject.toml
+CourseComparator/__init__.py
+CourseComparator/cc_classes.py
+CourseComparator/cc_functions.py
+CourseComparator.egg-info/PKG-INFO
+CourseComparator.egg-info/SOURCES.txt
+CourseComparator.egg-info/dependency_links.txt
+CourseComparator.egg-info/top_level.txt

coursecomparator-0.1.0/CourseComparator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

coursecomparator-0.1.0/CourseComparator.egg-info/top_level.txt

@@ -0,0 +1 @@
+CourseComparator

coursecomparator-0.1.0/LICENCE

@@ -0,0 +1,6 @@
+(c) 2024 BTBU | Vincy SHI
+
+A private software developed for the School 
+of Computer and Artificial Intelligence at 
+Beijing Technology and Business University. 
+For reference only. 

coursecomparator-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: CourseComparator
+Version: 0.1.0
+Summary: 用于比较不同的专业、届别或年级之间的课程设置，供转专业、降级学生确认可冲抵及需补修的课程。
+Author-email: Vincy SHI <vincy@vincy1230.net>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vincy1230/Course-Comparator
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: license-file
+
+# Course-Comparator 课程比较器
+
+用于比较不同的专业、届别或年级之间的课程设置，供转专业、降级学生确认可冲抵及需补修的课程。
+
+## 使用方法
+
+### 整理数据集
+
+将各个课程的数据集按照如下格式整理：
+
+`<数据集根目录>` / `<专业>` / `<届别>` / `<学期>.csv`
+
+例如，人工智能专业 2021 级第 1 ~ 8 学期的课程数据位于，分别存于：
+
+`<数据集根目录>` / `人工智能` / `2021` / `1.csv`
+`<数据集根目录>` / `人工智能` / `2021` / `2.csv`
+...
+`<数据集根目录>` / `人工智能` / `2021` / `8.csv`
+
+csv 文件的格式如下：
+
+| csv 表头    | 含义     | 示例             | 备注                   |
+| ----------- | -------- | ---------------- | ---------------------- |
+| course_code | 课程代码 | `MATA5B1001`     | 将解析为字符串         |
+| course_name | 课程名称 | `高等数学（上）` | 将解析为字符串         |
+| credit      | 课程学分 | `5`              | 将解析为浮点数         |
+| required    | 是否必修 | `1`              | `1` 为必修，`0` 为选修 |
+
+```csv
+course_code,course_name,credit,required
+MATA5B1001,高等数学（上）,5,1
+...
+```
+
+### 安装本软件包
+
+```bash
+pip install CourseComparator
+```
+
+### 运行程序
+
+```python
+# 导入课程比较器模块
+import CourseComparator as cc
+
+# 传入数据集根目录，初始化数据加载器
+loader = cc.init("<数据集根目录>")
+
+# 获取旧的课程方案
+old_courses = loader("<专业>", "<届别>", <学期>)
+
+# 获取新的课程方案
+new_courses = loader("<专业>", "<届别>", <学期>)
+
+# 打印两个方案的差异
+print(old_courses - new_courses)
+```

coursecomparator-0.1.0/README.md

@@ -0,0 +1,58 @@
+# Course-Comparator 课程比较器
+
+用于比较不同的专业、届别或年级之间的课程设置，供转专业、降级学生确认可冲抵及需补修的课程。
+
+## 使用方法
+
+### 整理数据集
+
+将各个课程的数据集按照如下格式整理：
+
+`<数据集根目录>` / `<专业>` / `<届别>` / `<学期>.csv`
+
+例如，人工智能专业 2021 级第 1 ~ 8 学期的课程数据位于，分别存于：
+
+`<数据集根目录>` / `人工智能` / `2021` / `1.csv`
+`<数据集根目录>` / `人工智能` / `2021` / `2.csv`
+...
+`<数据集根目录>` / `人工智能` / `2021` / `8.csv`
+
+csv 文件的格式如下：
+
+| csv 表头    | 含义     | 示例             | 备注                   |
+| ----------- | -------- | ---------------- | ---------------------- |
+| course_code | 课程代码 | `MATA5B1001`     | 将解析为字符串         |
+| course_name | 课程名称 | `高等数学（上）` | 将解析为字符串         |
+| credit      | 课程学分 | `5`              | 将解析为浮点数         |
+| required    | 是否必修 | `1`              | `1` 为必修，`0` 为选修 |
+
+```csv
+course_code,course_name,credit,required
+MATA5B1001,高等数学（上）,5,1
+...
+```
+
+### 安装本软件包
+
+```bash
+pip install CourseComparator
+```
+
+### 运行程序
+
+```python
+# 导入课程比较器模块
+import CourseComparator as cc
+
+# 传入数据集根目录，初始化数据加载器
+loader = cc.init("<数据集根目录>")
+
+# 获取旧的课程方案
+old_courses = loader("<专业>", "<届别>", <学期>)
+
+# 获取新的课程方案
+new_courses = loader("<专业>", "<届别>", <学期>)
+
+# 打印两个方案的差异
+print(old_courses - new_courses)
+```

coursecomparator-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "CourseComparator"
+version = "0.1.0"
+description = "用于比较不同的专业、届别或年级之间的课程设置，供转专业、降级学生确认可冲抵及需补修的课程。"
+authors = [{ name = "Vincy SHI", email = "vincy@vincy1230.net" }]
+readme = "README.md"
+license = "MIT"
+dependencies = []       
+
+[tool.setuptools.packages.find]
+include = ["CourseComparator*"]
+
+[project.urls]
+Homepage = "https://github.com/vincy1230/Course-Comparator"

coursecomparator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+