我的笔记

嘉兴考试培训网智慧学习小助手

普通版

import requests
import bs4

headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'}

# 获取登录信息
while True:
    username = input('请输入您的账号:')
    password = input('请输入您的密码:')

    #获得cookies
    url='http://m.jxkp.net/User/LoginCheck'
    data={
        'Uname': username,
        'Password': password,
        }
    login=requests.post(url,headers=headers,data=data)
    cookies=login.cookies
    if len(str(cookies)) > 100:
        break
    else:
        print('账号或密码错误')

while True:
    # number_list = '传统文化的保护传承与发展'
    number_list = input('请输入课程名：')

    # 找到相应的课程详情页
    url = 'http://m.jxkp.net/Zy/Kcs'
    res = requests.get(url,headers=headers)
    soup = bs4.BeautifulSoup(res.text,'html.parser')
    items = soup.find_all(class_='kc-item-wraplink')
    flag = False
    for item in items:
        alt = item.find('img')['alt']
        if alt == number_list:
            flag = True
            href = 'http://m.jxkp.net' + item['href']
            res = requests.get(href,headers=headers)
            soup = bs4.BeautifulSoup(res.text,'html.parser')
            items = soup.find_all(class_='kj-link')
            course_number = []
            for i in items:
                course_number.append(i['href'][-3:])
            break
    else:
        print('没有找到该课程，请重新输入课程名')
    if flag:
        break

count = 1
for j in course_number:
    #用cookies登陆
    for i in range(60,2401,60):
        url_2='http://m.jxkp.net/Person/UpdateKjLog'
        data = {
            't':str(i),
            'kjid':str(j),
            }
        res=requests.post(url_2,cookies=cookies,headers=headers,data=data)

        print(f'正在刷第{count}个视频，',i//60%483*'>',f'进度{round(i/2400*100,2)}%',end='\r')
    count += 1
    print()

极速版

from PySide6.QtWidgets import QApplication, QMainWindow, QPushButton,  QPlainTextEdit,QMessageBox,QLineEdit,QLabel
import requests
import bs4
from PySide6.QtCore import QThread, Signal, Slot, Qt 
import sys  
import time
from PySide6.QtGui import  QIcon

# 定义一个工作线程类  
class WorkerThread(QThread):  
    # 定义一个信号，用于在操作完成时发送结果  
    result_ready = Signal(str)  
  
    def __init__(self, course_number, cookies):  
        super().__init__()  
        # 存储传递进来的参数  
        self.course_number = course_number  
        self.cookies = cookies  

    def run(self):  
        headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'}
        url_2='http://m.jxkp.net/Person/UpdateKjLog'
        count = 1
        for j in self.course_number:
            progress_bar_count = 0
            for i in range(60,660,60):
                data = {
                    't':str(i),
                    'kjid':str(j),
                    }
                try:
                    requests.post(url_2,cookies=self.cookies,headers=headers,data=data)
                    progress_bar = '>' * int(progress_bar_count)  # 假设进度条长度为20个字符
                    # text = f'智慧小助手正在帮您学习第{count}个视频' 
                    text = f'智慧小助手正在帮您学习第{count}个视频，{progress_bar},进度{round(i/600*100,2)}%' 
                    # 使用信号发送结果  
                    self.result_ready.emit(text)  
                    progress_bar_count += 1
                except:
                    print('发生错误，跳过')
            count += 1
        # text = f'智慧小助手正在帮您学习第{count}个视频' 
        text = '智慧小助手已经帮您学习了所有课时，好用的话给个好评吧' 
        # 使用信号发送结果  
        self.result_ready.emit(text)  

class Stats(QMainWindow):
    def __init__(self):  
        super().__init__()  
        self.initUI()  

    def initUI(self):
        # 窗体设置
        self.window = QMainWindow()
        self.window.resize(500, 400)
        self.window.move(300, 300)
        self.window.setWindowTitle('嘉兴考试培训网智慧小助手')

        # 作者信息 
        self.author = QLabel(self.window)
        self.author.setText('作者：别问太多')
        # 手动设置QLabel的位置到右下角  
        self.author.move(self.window.width() - self.author.width() - 10,  
        self.window.height() - self.author.height() - 10) 
        # 用户名输入框
        self.username = QLineEdit(self.window)
        self.username.setPlaceholderText("请输入用户名")
        self.username.move(10, 25)
        self.username.resize(200,30)
        # 密码输入框
        self.password = QLineEdit(self.window)
        self.password.setPlaceholderText("请输入密码")
        self.password.setEchoMode(QLineEdit.Password)  # 设置密码输入模式
        self.password.move(10, 60)
        self.password.resize(200,30)
        # 课程名输入框
        self.course_name = QLineEdit(self.window)
        self.course_name.setPlaceholderText("请输入课程名")
        self.course_name.move(10, 100)
        self.course_name.resize(200,30)
        # 确认按钮
        self.button = QPushButton('启动', self.window)
        self.button.move(380, 80)
        self.button.clicked.connect(self.handleCalc)
        # 输出信息区域
        self.textEdit = QPlainTextEdit(self.window)
        self.textEdit.setPlaceholderText("程序尚未启动")
        self.textEdit.move(10,150)
        self.textEdit.resize(400,200)
        self.textEdit.setEnabled(False)

    # 服务器检验
    def checkServe(self):
        url = 'https://note.xiaolily.cn/%E5%98%89%E5%85%B4%E5%88%B7%E8%AF%BE%E6%97%B6.php'
        res = requests.get(url)
        if res.text == '1':
            return True
        else:
            QMessageBox.about(self.window,'提示','作者将软件停用了')
            return False

    # 校验账号密码
    def checkPassword(self):
        headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'}
        
        # 获取登录信息
        username = self.username.text()
        password = self.password.text()

        #获得cookies
        url='http://m.jxkp.net/User/LoginCheck'
        data={
            'Uname': username,
            'Password': password,
            }
        login=requests.post(url,headers=headers,data=data)
        self.cookies=login.cookies
        if len(str(self.cookies)) > 100:
            return True
        else:
            QMessageBox.about(self.window,'提示','账号或密码错误，请重新输入')
            return False

    # 获取课程信息
    def checkCourse(self):
        headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'}
        course_name = self.course_name.text()

        # 找到相应的课程详情页
        url = 'http://m.jxkp.net/Zy/Kcs'
        res = requests.get(url,headers=headers)
        soup = bs4.BeautifulSoup(res.text,'html.parser')
        items = soup.find_all(class_='kc-item-wraplink')
        flag = False
        for item in items:
            alt = item.find('img')['alt']
            if alt == course_name:
                flag = True
                href = 'http://m.jxkp.net' + item['href']
                res = requests.get(href,headers=headers)
                soup = bs4.BeautifulSoup(res.text,'html.parser')
                items = soup.find_all(class_='kj-link')
                self.course_number = []
                for i in items:
                    self.course_number.append(i['href'][-3:])
                break
        else:
            QMessageBox.about(self.window,'提示','找不到该课程名，请重新输入')
            return False
        if flag:
            return True

    # 开始学习视频
    def studyVideo(self):
        headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'}
        url_2='http://m.jxkp.net/Person/UpdateKjLog'
        count = 1
        for j in self.course_number:
            for i in range(60,2401,60):
                data = {
                    't':str(i),
                    'kjid':str(j),
                    }
                requests.post(url_2,cookies=self.cookies,headers=headers,data=data)
                text = f'智慧小助手正在帮您学习第{count}个视频' 
                self.textEdit.setPlainText(text)  
                break
            count += 1
            print()

    # 确定按钮点击事件
    def handleCalc(self):
        # 服务器检验
        if self.checkServe() == False:
            return False
        # 检查账号密码
        if self.checkPassword() == False:
            return False
        # 检查课程信息
        if self.checkCourse() == False:
            return False
        # self.studyVideo()
        self.start_single_task()

    # 开始学习视频
    def start_single_task(self):  
        # 创建工作线程实例，并传递参数  
        self.worker_thread = WorkerThread(self.course_number, self.cookies)  
        # 连接工作线程的result_ready信号到主窗口的槽函数  
        self.worker_thread.result_ready.connect(self.on_result_ready)  
        # 启动工作线程  
        self.worker_thread.start()   

    @Slot(str)  
    def on_result_ready(self, result):  
        # 在GUI线程中安全地更新文本编辑框的内容  
        self.textEdit.setPlainText(result)     

# 主程序  
if __name__ == "__main__":  
    app = QApplication(sys.argv)  
    # 加载 icon
    app.setWindowIcon(QIcon('favicon.ico'))
    stats = Stats()  
    stats.window.show()  
    sys.exit(app.exec())

嘉兴考试培训网智慧考试小助手

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import os,time,requests
import logging
import sys
from urllib3.exceptions import InsecureRequestWarning
from selenium.webdriver.chrome.service import Service as ChromeService
from webdriver_manager.chrome import ChromeDriverManager
import os

# AI回答
def AI_answer(content):
    content = content + '(请使用中文回答)'
    url = "https://ps7491619bs.vicp.fun/AI_my_chat.php"
    params = {
        'user_input': content,
        'password':'zhaoguodong'
    }
    res = requests.get(url,params=params)
    res_json = res.json()
    answer = res_json['message']['content']
    return answer

def close_current_window(driver, fallback_window=None):
    """安全关闭当前窗口并切换到备用窗口"""
    if len(driver.window_handles) <= 1:
        print("警告：这是最后一个窗口，跳过关闭")
        return
    
    if fallback_window and fallback_window in driver.window_handles:
        # 切换到备用窗口后再关闭当前窗口
        driver.switch_to.window(fallback_window)
        for handle in driver.window_handles:
            if handle != fallback_window:
                driver.switch_to.window(handle)
                driver.close()
        driver.switch_to.window(fallback_window)
    else:
        # 没有指定备用窗口时，切换到剩余的第一个窗口
        current = driver.current_window_handle
        other_windows = [h for h in driver.window_handles if h != current]
        
        if other_windows:
            driver.switch_to.window(other_windows[0])
            driver.close()
        else:
            print("无法关闭：没有其他窗口")

# 获得新打开窗口的句柄
def get_current_window(driver):
    # 获取当前所有窗口句柄  
    all_window_handles = driver.window_handles  
    
    # 获取当前窗口句柄  
    current_window_handle = driver.current_window_handle  
    
    # 寻找新打开的标签页的句柄  
    new_window_handle = None  
    for handle in all_window_handles:  
        if handle != current_window_handle:  
            new_window_handle = handle  
            break  
    
    # 切换到新标签页  
    if new_window_handle:  
        driver.switch_to.window(new_window_handle)  
    else:  
        print("无法打开句柄")

def setup_logging():
    """配置日志，抑制不必要的警告"""
    # 配置Python日志
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        stream=sys.stdout
    )
    
    # 抑制absl库的初始化警告
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'  # 0=所有日志，1=忽略info，2=忽略warning，3=忽略error
    
    # 抑制Selenium/Chrome的特定日志
    options = webdriver.ChromeOptions()
    options.add_experimental_option('excludeSwitches', ['enable-logging'])
    return options

def create_chrome_driver():
    """创建Chrome浏览器驱动实例"""
    # 获取当前Python脚本所在目录
    # current_dir = os.path.dirname(os.path.abspath(__file__))
    # 构建chromedriver.exe的路径
    # driver_path = os.path.join(current_dir, 'chromedriver.exe')
    # 创建Service对象
    # service = Service(driver_path)
    # os.environ["WDM_SSL_VERIFY"] = "0"  # 关闭SSL验证（部分镜像需）
    # os.environ["WDM_LOCAL"] = "1"       # 优先使用本地缓存
    # os.environ["WDM_HTTPCLIENT"] = "tls" # 解决TLS兼容问题

    # # 指定阿里云镜像（可选）
    # os.environ["WDM_API_URL"] = "https://registry.npmmirror.com/-/binary/chromedriver"
    print('初次打开会更新驱动，请等待60秒')
    service=ChromeService(ChromeDriverManager().install())

    # 获取配置好的浏览器选项
    options = setup_logging()
    
    # 添加选项（根据需要取消注释）
    # options.add_argument('--headless')  # 无头模式
    # options.add_argument('--disable-gpu')  # 禁用GPU加速
    # options.add_argument('--window-size=1920,1080')  # 设置窗口大小
    
    # 初始化Chrome浏览器驱动
    driver = webdriver.Chrome(service=service, options=options)
    return driver

# 核销使用码
def yzm_use():
    while True:
        # 禁用SSL证书验证警告
        requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)
        yzm = input('请输入使用码：')
        url = 'https://backend.xiaolily.cn/public/verify_code'
        params = {
            'code':yzm
        }
        # 完全信任网站的ssl证书
        res = requests.post(url,params=params,verify=False)
        res_json = res.json()
        if res_json['code'] == 200:
            print(res_json['msg'])
            break
        else:
            print(res_json['msg'])


def main():
    yzm_use()

    # 获取登录信息
    while True:
        username_input = input('请输入用户名：')
        password_input = input('请输入密码：')
        course_name = input('请输入课程名：')
        #获得cookies
        headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'}
        url='http://m.jxkp.net/User/LoginCheck'
        data={
            'Uname': username_input,
            'Password': password_input,
            }
        login=requests.post(url,headers=headers,data=data)
        cookies=login.cookies
        if len(str(cookies)) > 100:
            break
        else:
            print('账号或密码错误，请重新输入')

    # 创建 Chrome 驱动实例
    driver = create_chrome_driver()
    try:
        # 登录页面
        target_url = "http://m.jxkp.net/User/Login?ReturnUrl=%2FUser"  
        driver.get(target_url)
        time.sleep(2)
        # 有可能遇到不支持ssl，点击继续访问
        try:
            jixufangwen = driver.find_element(By.ID,'proceed-button')
            jixufangwen.click()
            time.sleep(2)
        except:
            # 没有遇到ssl
            pass
        # 账号
        username = driver.find_element(By.ID,'Uname')
        username.send_keys(username_input) 
        # 密码
        username = driver.find_element(By.ID,'Password')
        username.send_keys(password_input) 
        # 登录按钮
        login_button = driver.find_element(By.CLASS_NAME,'button')
        login_button.click()
        time.sleep(3)
        print('已成功登录平台')
        # 考试页面
        flag = False
        while True:
            driver.get('http://m.jxkp.net/Person/ExamList') 
            tag_elements = driver.find_elements(By.CLASS_NAME,'kc-list-row')
            # 找到对应的课程  
            for element in tag_elements:  
                if course_name in element.text:  
                    # 考试按钮
                    exam_button = element.find_element(By.LINK_TEXT,'参加考试')
                    exam_button.click() # 点击【提交】按钮 
                    flag = True
                    break
            
            if flag == True:
                break
            else:
                print('1、没有这门课程')
                print('2、课时没刷完不能考试')
                print('3、已经达到了最大考试次数')
                # 关闭浏览器
                driver.quit()
                input('请按下回车键退出程序')

        print('成功进入考试页面')
        time.sleep(3)
        element_list = driver.find_elements(By.CLASS_NAME, "ques") 
        for element in element_list:
            # 查找所有type为hidden的input元素
            values = element.find_elements(By.CSS_SELECTOR, 'input[type="hidden"][name="ques"]')
            for value in values:
                # 选项的定位元素ans_10220
                value_name = 'ans_' + value.get_attribute('value')
                # 获取紧邻的下一个兄弟元素
                title = value.find_element(By.XPATH, "following-sibling::*[1]").text
                # A = value.find_element(By.XPATH, "following-sibling::*[2]").text
                # B = value.find_element(By.XPATH, "following-sibling::*[3]").text
                # C = value.find_element(By.XPATH, "following-sibling::*[4]").text
                # D = value.find_element(By.XPATH, "following-sibling::*[5]").text
                # 收集class为"ans"的兄弟元素，直到遇到下一个value元素为止
                all_following_siblings = value.find_elements(By.XPATH, "following-sibling::*")
                # 获取当前value元素之后的所有兄弟元素
                answer_elements = []
                for sibling in all_following_siblings:
                    # 如果遇到下一个value元素，停止收集
                    if sibling.get_attribute("name") == "ques":
                        break
                    # 收集class包含"ans"的元素
                    if "ans" in sibling.get_attribute("class"):
                        answer_elements.append(sibling)
                # 提取每个选项的文本
                answers = str([elem.text for elem in answer_elements]) 
                timu = title + answers + ',请只回答我答案（A、B、C、D）'  
                answer = AI_answer(timu)
                print(answer)
                # 在打开新窗口前，保存原始窗口句柄
                # original_window = driver.current_window_handle
                # 打开豆包（失败方案，豆包未登录只能使用五次）
                # driver.execute_script("window.open('');")  
                # get_current_window(driver)
                # driver.get('https://www.doubao.com/chat/') 
                # time.sleep(3)
                # textarea = driver.find_element(By.TAG_NAME, "textarea")
                # textarea.send_keys(timu)
                # textarea.send_keys(Keys.RETURN)
                # while True:
                #     try:
                #         answer = driver.find_element(By.CLASS_NAME, "auto-hide-last-sibling-br").text
                #         time.sleep(3)
                #         break
                #     except:
                #         pass
                # 关闭窗口
                # close_current_window(driver, fallback_window=original_window)
                # time.sleep(2)
                xuanxiang_name = element.find_element(By.CSS_SELECTOR, f'input[name="{value_name}"]')
                xuanxiang_value = int(xuanxiang_name.get_attribute('value')) 
                if answer == 'A':
                    xuanxiang_value = str(xuanxiang_value) 
                elif answer == 'B':
                    xuanxiang_value = str(xuanxiang_value + 1) 
                elif answer == 'C':
                    xuanxiang_value = str(xuanxiang_value + 2) 
                else:
                    xuanxiang_value = str(xuanxiang_value + 3) 
                
                try:
                    xiangxuan = element.find_element(By.CSS_SELECTOR, f'input[value="{xuanxiang_value}"]')
                    # 使用JavaScript滚动到元素位置
                    driver.execute_script("arguments[0].scrollIntoView(true);", xiangxuan)
                    # 向上调整位置（假设导航栏高度为50px）
                    driver.execute_script("window.scrollBy(0, -50);")
                    # 等待页面滚动完成
                    time.sleep(0.5)    
                    xiangxuan.click()
                except:
                    print('发生未知错误，跳过')
        
        # 等待用户输入，防止浏览器自动关闭
        input("按回车键关闭浏览器...")
        
    except Exception as e:
        print(f"发生错误: {e}")
    finally:
        # 关闭浏览器
        driver.quit()

if __name__ == "__main__":
    main()