Python 自动评分机器人：百分制、小分值、论坛打分功能实现

Python 自动评分机器人：百分制、小分值、论坛打分功能实现

本代码使用 Python 编写一个自动评分机器人，能够实现三种打分模式：百分制打分、小分值打分和论坛打分，并提供暂停功能。

代码实现

import os
import random
import time
import tkinter as tk
from threading import Thread

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By


class AutoScore100:
    def __init__(self):
        self.running = False
        self.paused = False
        self.forum_paused = False  # 论坛打分暂停标志
        self.browser = None
        self.thread = None
        self.score_thread = None
        self.forum_thread = None

        self.root = tk.Tk()
        self.root.title('评分机器人1.2')
        self.root.geometry('300x500')

        # 创建按钮容器
        button_frame = tk.Frame(self.root)
        button_frame.pack(pady=10)

        # 创建“开始运行”和“停止运行”按钮
        self.start_button = tk.Button(button_frame, text='开始运行', command=self.start_program)
        self.start_button.pack(side=tk.LEFT, padx=20)
        self.stop_score_button = tk.Button(button_frame, text='停止运行', command=self.stop_program)
        self.stop_score_button.pack(side=tk.LEFT)

        # 创建“百分制打分”、“小分值打分”和“论坛打分”按钮
        score_frame = tk.Frame(self.root)
        score_frame.pack(pady=10)
        self.start_score_button = tk.Button(score_frame, text='百分值打分', command=self.start_score_100)
        self.start_score_button.pack(side=tk.LEFT, padx=20)
        self.start_score_button_2 = tk.Button(score_frame, text='小分值打分', command=self.start_score)
        self.start_score_button_2.pack(side=tk.LEFT)
        self.start_forum_button = tk.Button(score_frame, text='论坛打分', command=self.start_forum_score)
        self.start_forum_button.pack(side=tk.LEFT, padx=20)

        # 创建“暂停打分”按钮和状态标签
        self.pause_button = tk.Button(self.root, text='暂停打分', command=self.pause_program)
        self.pause_button.pack(pady=10)
        self.running_label = tk.Label(self.root, text='')
        self.running_label.pack(pady=10)

        # 创建提示标签
        self.text_box = tk.Text(self.root, height=50, state='disabled')
        self.text_box.pack(pady=50)

        # 创建浏览器实例
        options = Options()
        options.add_experimental_option("debuggerAddress", "127.0.0.1:9222")
        try:
            self.browser = webdriver.Chrome(options=options)
        except:
            pass

    def start_program(self):
        if self.running:
            return

        self.running = True
        if not self.browser:
            os.system(r'start chrome --remote-debugging-port=9222 --user-data-dir="D:\评阅用"')
            options = Options()
            options.add_experimental_option("debuggerAddress", "127.0.0.1:9222")
            self.browser = webdriver.Chrome(options=options)
        self.thread = Thread(target=self.run_program)
        self.thread.start()
        self.start_button.config(state='disabled')
        self.start_score_button.config(state='normal')
        self.start_score_button_2.config(state='normal')
        self.pause_button.config(state='normal')
        self.stop_score_button.config(state='normal')

    def start_score_100(self):
        if not self.running:
            return

        if self.score_thread and self.score_thread.is_alive():
            return

        self.start_score_button.config(state='disabled')
        self.start_score_button_2.config(state='disabled')
        self.stop_score_button.config(state='normal')
        self.update_running_label('百分制打分中...')
        self.score_thread = Thread(target=self.score_program_100)
        self.score_thread.start()

    def start_score(self):
        if not self.running:
            return

        if self.score_thread and self.score_thread.is_alive():
            return

        self.start_score_button.config(state='disabled')
        self.start_score_button_2.config(state='disabled')
        self.stop_score_button.config(state='normal')
        self.update_running_label('小分值打分中...')
        self.score_thread = Thread(target=self.score_program)
        self.score_thread.start()

    def start_forum_score(self):
        if not self.running:
            return

        if self.forum_thread and self.forum_thread.is_alive():
            return

        self.start_forum_button.config(state='disabled')
        self.stop_score_button.config(state='normal')
        self.update_running_label('论坛打分中...')
        self.forum_thread = Thread(target=self.forum_score_program)
        self.forum_thread.start()

    def stop_program(self):
        self.running = False
        self.paused = False
        self.forum_paused = False  # 将论坛打分暂停标志设置为False
        self.start_button.config(state='normal')
        self.start_score_button.config(state='disabled')
        self.start_score_button_2.config(state='disabled')
        self.stop_score_button.config(state='disabled')
        self.pause_button.config(state='disabled')
        self.update_running_label('已停止运行')

    def pause_program(self):
        if not self.running:
            return

        if self.paused:
            self.paused = False
            self.forum_paused = False  # 将论坛打分暂停标志设置为False
            self.pause_button.config(text='暂停')
            self.start_score_button.config(state='normal')
            self.start_score_button_2.config(state='normal')
            self.update_running_label('继续运行')
        else:
            self.paused = True
            self.forum_paused = True  # 将论坛打分暂停标志设置为True
            self.pause_button.config(text='继续')
            self.start_score_button.config(state='disabled')
            self.start_score_button_2.config(state='disabled')
            self.update_running_label('已暂停')

    def update_running_label(self, text):
        self.running_label.config(text=text)

    def run_program(self):
        while self.running:
            while self.paused:
                time.sleep(0.5)

            self.update_running_label('等待登录...')
            try:
                # 从最后的标签页向前寻找
                for handle in reversed(self.browser.window_handles):
                    self.browser.switch_to.window(handle)
                    if '内蒙古开放大学' in self.browser.title:
                        self.update_running_label('登录成功')
                        self.start_score_button.config(state='normal')
                        self.start_score_button_2.config(state='normal')
                        break
                else:
                    self.update_running_label('未登录')
                    time.sleep(5)
                    continue
                break
            except Exception as e:
                print(e)
                continue

    def score_program_100(self):
        try:
            # 循环打分100分值
            while True:
                if not self.running:
                    break

                if self.paused:
                    continue

                score_box = self.browser.find_element(By.CLASS_NAME, 'score-box')
                score_input = score_box.find_element(By.TAG_NAME, 'input')
                score_input.clear()
                score = random.randint(94, 99)
                score_input.send_keys(str(score))
                time.sleep(1.5)
                submit_button = self.browser.find_element(By.CLASS_NAME, 'nav-text')
                submit_button.click()
                time.sleep(2.5)
                self.update_text_box(f"本次题目分值为：{score}")
                if '已到最后' in self.browser.page_source:
                    self.update_running_label('已到最后，请手动保存后重新开始！')
                    break
                else:
                    self.update_running_label('百分制打分中...')

        except Exception as e:
            print(e)
            self.update_running_label('百分制打分失败，请重试')
        finally:
            self.start_score_button.config(state='normal')
            self.start_score_button_2.config(state='normal')
            self.stop_score_button.config(state='disabled')
            self.pause_button.config(state='disabled')

    def score_program(self):
        try:
            # 循环打分小分值
            while True:
                if not self.running:
                    break

                if self.paused:
                    continue

                # 等待题目组出现
                while True:
                    try:
                        elements = self.browser.find_elements(By.CLASS_NAME, "card-div")
                        if elements:
                            break
                    except:
                        pass
                    time.sleep(3)

                score_list = []
                subject_number_list = []
                for element in elements:
                    # 查找待批改元素
                    card_score_element = element.find_element(By.CLASS_NAME, "card-score")
                    if "待批改" not in card_score_element.text:
                        continue
                    # 查找题号元素
                    subject_number_element = element.find_element(By.CLASS_NAME, "subject-number")
                    subject_number_text = subject_number_element.text
                    # 提取题号
                    subject_number = ""
                    for char in subject_number_text:
                        if char.isdigit():
                            subject_number += char
                    subject_number_list.append(subject_number)
                    self.update_text_box(f"待批改的题目号为：{subject_number}
")

                    # 判断是否作答
                    answered = False
                    elements = self.browser.find_elements(By.ID, f"subject-{subject_number}")
                    for element in elements:
                        answer_content_element = element.find_elements(By.CLASS_NAME, "answer-content")
                        if answer_content_element:
                            answered = True
                            break
                    if not answered:
                        self.update_text_box(f"第{subject_number}题未作答，不获取分值
")
                        continue

                    # 查找题目分值
                    summary_numbers = []
                    for element in elements:
                        summary_element = element.find_element(By.CLASS_NAME, "summary-sub-title")
                        summary_text = summary_element.text
                        summary_number = ""
                        for char in summary_text:
                            if char.isdigit() or char == '.':
                                summary_number += char
                        summary_numbers.append(float(summary_number))
                        self.update_text_box(f"第{subject_number}题的分值为：{summary_number}
")

                    # 将题目分值存入列表
                    score_list.extend(summary_numbers)

                # 如果只有一个题目，则对这道题的分值减去1-2分；如果只有一个题目，并且题目的分值大于等于50，则对这道题的分值减1-5分，
                if len(score_list) == 1:
                    if score_list[0] >= 50:
                        score_list[0] -= random.randint(1, 5)
                    else:
                        score_list[0] -= random.randint(1, 2)
                        self.update_text_box(f"第{subject_number_list[0]}题减{score_list[0]}分，已填入{score_list[0]}分")
                else:
                    # 随机选择2-5个题目减分
                    if len(score_list) <= 5:
                        reduce_num = len(score_list) - 1
                    else:
                        reduce_num = random.randint(2, 5)
                    # 对样本数量进行判断
                    if reduce_num > len(score_list) - 1:
                        reduce_num = len(score_list) - 1
                    elif reduce_num < 0:
                        reduce_num = 0
                    reduce_index_list = random.sample(range(len(score_list)), reduce_num)

                    # 对选择的题目减分
                    for i in reduce_index_list:
                        subject_number = subject_number_list[i]
                        reduce_score = random.randint(1, 2)
                        score_list[i] -= reduce_score
                        self.update_text_box(f"第{subject_number}题减{reduce_score}分，已填入{score_list[i]}分")

                # 将分值填入分值框中
                for i, subject_number in enumerate(subject_number_list):
                    elements = self.browser.find_elements(By.ID, f"subject-{subject_number}")
                    for element in elements:
                        score_element = element.find_element(By.NAME, "score")
                        score_element.clear()
                        score_element.send_keys(str(score_list[i]))
                        time.sleep(1.5)

                # 等待提交成功
                while True:
                    try:
                        self.browser.find_element(By.CLASS_NAME, "toast-message")
                        time.sleep(1.5)
                    except:
                        break

                # 点击下一个学生
                next_student_element = self.browser.find_element(By.CLASS_NAME, "icon-student-right-narrow")
                if "unclickable" in next_student_element.get_attribute("class"):
                    print("已经到最后一个学生")
                    self.update_running_label('已到最后，请手动保存后重新开始！')
                    break
                else:
                    next_student_element.click()
                    time.sleep(3)
                    self.update_running_label('小分值打分中...')

        except Exception as e:
            print(e)
            self.update_running_label('打分失败，请重试')
        finally:
            self.start_score_button.config(state='normal')
            self.start_score_button_2.config(state='normal')
            self.stop_score_button.config(state='disabled')
            self.pause_button.config(state='disabled')

    def forum_score_program(self):
        try:
            # 循环打分论坛分值
            while True:
                if not self.running:
                    break

                if self.paused or self.forum_paused:  # 检查暂停标志
                    continue

                # 等待论坛打分输入框出现
                while True:
                    try:
                        forum_score_input = self.browser.find_element(By.XPATH,
                                                                       '//input[@ng-model="currentEnrollment.forum_score.'
                                                                       'display_score"]')
                        break
                    except:
                        pass
                    time.sleep(3)

                # 判断是否有内容
                try:
                    forum_score_element = self.browser.find_element(By.XPATH,
                                                                    '//span[@ng-bind="currentEnrollment.sum_of_posts"]')
                    forum_score_text = forum_score_element.text
                    forum_score = int(forum_score_text)
                    if forum_score >= 1:
                        # 填写分值
                        score = random.randint(94, 99)
                        forum_score_input.clear()
                        forum_score_input.send_keys(str(score))
                        time.sleep(1.5)
                        self.update_text_box(f"本次论坛分值为：{score}")
                        self.update_running_label('论坛打分中...')
                    else:
                        self.update_text_box('该学生论坛未提交')
                except:
                    self.update_text_box('该学生论坛未提交')
                # 点击下一个学生
                next_student_element = self.browser.find_element(By.XPATH, '//i[@ng-click="goToNextStudent()"]')
                if "disabled" in next_student_element.get_attribute("class"):
                    self.update_running_label('已到最后，请手动保存后重新开始！')
                    break
                else:
                    next_student_element.click()
                    time.sleep(3)
                    self.update_running_label('论坛打分中...')

        except Exception as e:
            print(e)
            self.update_running_label('论坛打分失败，请重试')
        finally:
            self.start_forum_button.config(state='normal')
            self.stop_score_button.config(state='disabled')
            self.pause_button.config(state='disabled')

    def run(self):
        self.root.mainloop()

    def update_text_box(self, text):
        self.text_box.config(state='normal')
        self.text_box.insert('end', text + '
')
        self.text_box.see('end')
        self.text_box.config(state='disabled')

if __name__ == '__main__':
    auto_score_100 = AutoScore100()
    auto_score_100.run()

解决方案

1. 在 AutoScore100 类的 __init__ 方法中添加一个论坛打分暂停标志：

self.forum_paused = False

2. 在论坛打分功能的代码中添加一个循环，用于检查论坛打分暂停标志：

while True:
    if not self.running:
        break

    if self.paused or self.forum_paused:  # 检查暂停标志
        continue

    # 论坛打分的代码

3. 在暂停按钮的回调函数 pause_program 中，将论坛打分暂停标志设置为 True：

def pause_program(self):
    if not self.running:
        return

    if self.paused:
        self.paused = False
        self.forum_paused = False  # 将论坛打分暂停标志设置为False
        self.pause_button.config(text='暂停')
        self.start_score_button.config(state='normal')
        self.start_score_button_2.config(state='normal')
        self.update_running_label('继续运行')
    else:
        self.paused = True
        self.forum_paused = True  # 将论坛打分暂停标志设置为True
        self.pause_button.config(text='继续')
        self.start_score_button.config(state='disabled')
        self.start_score_button_2.config(state='disabled')
        self.update_running_label('已暂停')

这样，当暂停按钮被按下时，论坛打分功能会暂停执行，等待暂停按钮被释放后，才会继续执行。

代码解释

1. 添加论坛打分暂停标志：

   • 在 AutoScore100 类的 __init__ 方法中添加 self.forum_paused = False，用于记录论坛打分是否处于暂停状态。

2. 检查暂停标志：

   • 在 forum_score_program 函数中，添加 if self.paused or self.forum_paused: continue，检查当前是否处于暂停状态。如果是，则跳过当前循环，等待恢复。

3. 控制暂停标志：

   • 在 pause_program 函数中，根据当前状态，将 self.forum_paused 设置为 True 或 False，控制论坛打分功能的暂停和恢复。

通过以上步骤，您就可以将暂停功能应用于论坛打分功能，实现更灵活的控制。