作者: AI最严厉的父亲

  • 如何使用Python优化爬虫和数据可视化

    你是否曾经想过如何从Bilibili网站上获取有关UP主的信息,并将其可视化呈现出来?本教程将向你展示如何使用Python、Selenium、Pandas和Matplotlib优化你的爬虫和数据可视化流程,以更轻松地收集和分析数据。

    前言

    在这个信息爆炸的时代,我们有许多方法来获取数据。而对于喜欢Bilibili的用户来说,UP主的粉丝数量和内容质量是非常关键的信息。我们将使用Python编程语言来自动抓取Bilibili上UP主的信息,并通过数据可视化来更好地理解这些数据。

    准备工作

    在开始之前,确保你已经安装了以下Python库:

    • Pandas:用于数据处理和分析。
    • Matplotlib:用于数据可视化。
    • Selenium:用于网页自动化操作。

    你还需要下载Microsoft Edge浏览器驱动,确保与你的浏览器版本相匹配。现在,让我们开始吧!

    第一步:设置环境

    首先,让我们设置Python环境并导入必要的库:

    import pandas as pd
    import matplotlib.pyplot as plt
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    import pinyin

    在这里,我们导入了所需的库,包括Pandas用于数据处理、Matplotlib用于可视化、Selenium用于网页自动化操作以及pinyin用于处理拼音。

    第二步:设置中文显示

    由于我们将处理中文字符,我们需要设置Matplotlib以正确显示中文字符:

    plt.rcParams["font.sans-serif"] = ["SimHei"]
    plt.rcParams["axes.unicode_minus"] = False

    这将确保你的可视化图表中可以正确显示中文。

    第三步:编写辅助函数

    在进行爬取和数据处理之前,我们将编写一些辅助函数来处理文字数据:

    def getStrAllAlpha(string):
        return pinyin.get_initial(string, delimiter="").upper()
    
    def getStrFirstAlpha(string):
        string = getStrAllAlpha(string)
        string = string[0:1]
        return string.upper()

    这两个函数将用于将UP主的名字转换为拼音,并提取首字母,以便后续的数据整理。

    第四步:爬取UP主信息

    现在,让我们开始爬取Bilibili上UP主的信息。我们将使用Selenium来自动化这个过程。首先,设置Bilibili的搜索页面URL:

    url = "https://search.bilibili.com/upuser?keyword=mc&from_source=webtop_search&spm_id_from=333.1007&order=fans"

    接下来,设置浏览器的User-Agent,以模拟用户操作:

    header = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36'}
    opt = webdriver.EdgeOptions()
    opt.add_argument('--user-agent=%s' % header)
    edge = webdriver.Edge(options=opt)

    然后,让浏览器打开Bilibili的搜索页面:

    edge.get(url)

    现在,我们准备开始爬取UP主信息。我们将循环爬取100个UP主的名字和粉丝数量,并将它们存储在两个列表中:

    name_list = []
    people_list = []
    
    for i in range(1, 101):
        try:
            # 使用XPath定位UP主信息
            li = edge.find_element(by=By.XPATH, value='//*[@id="user-list"]/div[1]/ul/li[' + str(i) + ']')
            txt = li.text
            name = txt.split("\n")[0].split("+")[0]
            people = txt.split("\n")[2].split(":")[1].split("万")[0]
            name_list.append(name)
            people_list.append(float(people))
            print(name, people)
        except:
            print("切页")
            # 点击下一页按钮
            button = edge.find_element(by=By.XPATH, value='//*[@id="user-list"]/div[1]/div[2]/div/ul/li[' + str(page) + ']/button').click()
            page += 1

    这个循环将遍历100个UP主的信息,并将它们存储在两个列表中。如果需要翻页,它还会自动点击下一页按钮。

    第五步:数据整理

    现在,我们已经成功爬取了UP主的信息,接下来让我们对数据进行整理。首先,我们将按照首字母对UP主进行分类:

    abc_name = []
    abc_name2 = []
    abc_people = []
    abc_people2 = []
    abc = "A"
    
    for i in range(26):
        for j in name_list:
            if getStrFirstAlpha(j) == abc:
                abc_name.append(j)
                tt = name_list.index(j)
        abc = chr(ord(abc) + 1)
    
    for id in abc_name:
        if id not in abc_name2:
            abc_name2.append(id)
    
    for i in abc_name2:
        abc_people2.append(people_list[name_list.index(i)])

    这段代码会将UP主按照首字母进行分类,并创建两个新的列表,分别存储UP主的名字和粉丝数量。

    第六步:数据保存

    我们将整理好的数据保存为CSV文件,以备后续分析和可视化使用:

    data = pd.DataFrame({"UP主名字": name_list, "粉丝数量/万": people_list})
    data.to_csv("up主信息.csv")
    
    data = pd.DataFrame({"UP主名字": abc_name2, "粉丝数量/万": abc_people2})
    data.to_csv("按首字母分类.csv")

    这将创建两个CSV文件

    ,分别存储UP主的详细信息和按首字母分类的信息。

    第七步:数据可视化

    现在,我们已经成功获取和整理了UP主的信息,接下来让我们使用Matplotlib进行数据可视化。我们将创建两个柱状图,一个显示所有UP主的粉丝数量,另一个按首字母分类显示:

    plt.subplot(1, 2, 1)
    bar1 = plt.bar(name_list, people_list, color=['r', 'r', 'r', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b'])
    plt.xticks(rotation=90, fontsize=13)
    plt.bar_label(bar1, label_type='edge')
    
    plt.subplot(1, 2, 2)
    bar2 = plt.bar(abc_name2, abc_people2, color=['r', 'r', 'r', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b'])
    plt.bar_label(bar2, label_type='edge')
    plt.xticks(rotation=90, fontsize=13)
    
    plt.show()

    这段代码会创建两个子图,一个显示所有UP主的粉丝数量,另一个按首字母分类显示。最后,通过plt.show()将图表显示出来。

    总结

    通过这个教程,你学会了如何使用Python、Selenium、Pandas和Matplotlib来爬取Bilibili上UP主的信息,并将其进行数据整理和可视化。这对于分析UP主的粉丝数量和分类是非常有用的。

    现在,你可以探索更多的数据分析和可视化方法,或者将这些数据用于其他有趣的项目。希望这个教程对你有所帮助!

  • 如何创建一个自动化按键和鼠标点击工具

    在日常计算机使用中,我们常常需要进行重复性的操作,例如定时按下某个键盘按键或模拟鼠标点击。这可能涉及到玩游戏、自动化测试、数据录入等各种场景。为了实现这些功能,你可以创建一个自动化按键和鼠标点击工具。本教程将介绍如何使用Python和一些库来创建这样的工具。

    1. 开场故事

    想象一下,你正在玩一个需要不断点击鼠标的游戏,或者你需要在浏览器上定期执行某项任务。每次都手动点击或按下键盘按键是多么繁琐和乏味!那么,有没有一种方法可以自动化这些操作,让计算机来代劳呢?答案是肯定的,本文将向你展示如何创建一个自动化按键和鼠标点击的工具,让你告别重复性操作的困扰。

    2. 准备工作

    在开始之前,我们需要准备一些工具和库。首先,你需要安装Python,如果你还没有安装,可以从官方网站下载并安装。接下来,我们将使用以下库:

    • PyQt5:用于创建图形用户界面。
    • pynput:用于监听键盘和鼠标事件。
    • pygetwindow:用于获取当前活动窗口的信息。
    • pyautogui:用于模拟键盘按键和鼠标点击事件。

    你可以使用以下命令安装这些库:

    pip install PyQt5 pynput pygetwindow pyautogui

    3. 创建图形用户界面

    首先,我们将创建一个图形用户界面(GUI),以便用户可以轻松地控制自动化工具。我们将使用PyQt5库来构建GUI。以下是一个示例GUI的代码:

    from PyQt5 import QtWidgets, uic
    from PyQt5.QtGui import QPainter, QColor, QCursor
    from PyQt5.QtCore import Qt, QRectF
    from pynput.mouse import Button, Controller
    import pyautogui
    import threading
    import time
    import os
    
    # ... 其他代码 ...
    
    class Ui(QtWidgets.QMainWindow):
        def __init__(self):
            super(Ui, self).__init__()
            uic.loadUi(ui_path, self)
    
            # ... 创建GUI元素 ...
    
            self.show()
    
    # ... 其他代码 ...

    在这个GUI中,我们可以添加按键、设置时间间隔、监控按键状态等功能。

    4. 监听键盘和鼠标事件

    接下来,我们将创建一个用于监听键盘和鼠标事件的类。我们使用pynput库来实现这一功能。以下是一个示例代码片段:

    from pynput import keyboard, mouse
    import pygetwindow as gw
    
    class Controller:
        def __init__(self):
            self.mouse_controller = mouse.Controller()
            self.mouse_pressed = False
            self.keyboard_stop_flag = True
            self.mouse_auto_stop_flag = True
    
        def on_press(self, key):
            try:
                # 检查游戏是否运行并且是当前活动窗口
                # game_windows = gw.getWindowsWithTitle(self.game_title)
                # if game_windows and gw.getActiveWindow() in game_windows:
                if key == keyboard.Key.f1:
                    if self.keyboard_stop_flag:
                        self.keyboard_stop_flag = False
                        window.statusButton.setChecked(True)
                        self.start_keyboard_press_key()
                    else:
                        self.keyboard_stop_flag = True
                        window.statusButton.setChecked(False)
                elif key == keyboard.Key.f2:
                    # 鼠标连点
                    if self.mouse_auto_stop_flag:
                        self.mouse_auto_stop_flag = False
                        window.mouseStatusButton.setChecked(True)
                        self.start_mouse_auto_click_key(self.MOUSE_STATUS_CLICK)
                    else:
                        self.mouse_auto_stop_flag = True
                        window.mouseStatusButton.setChecked(False)
                elif key == keyboard.Key.f3:
                    # 鼠标长按
                    if self.mouse_auto_stop_flag:
                        self.mouse_auto_stop_flag = False
                        window.mouseStatusButton.setChecked(True)
                        self.start_mouse_auto_click_key(self.MOUSE_STATUS_PRESS)
                    else:
                        self.mouse_auto_stop_flag = True
                        window.mouseStatusButton.setChecked(False)
                elif key == keyboard.Key.f4:
                    # 按键映射
                    pass
                elif key == keyboard.Key.f12:
                    mouse_pos = QCursor.pos()
                    global mouseX, mouseY
                    mouseX = mouse_pos.x()
                    mouseY = mouse_pos.y()
                    window.xPos.setText(str(mouseX))
                    window.yPos.setText(str(mouseY))
                else:
                    print(f"{key} pressed")
            except Exception as e:
                import traceback
                traceback.print_exc()
    
        # ... 其他代码 ...

    在这个类中,我们定义了一个Controller类,用于监听键盘和鼠标事件。根据按键的不同,我们可以执行不同的操作,例如启动键盘按键模拟、鼠标点击等。

    5. 创建自动化操作

    现在,我们可以创建自动化的操作,例如模拟键盘按键和鼠标点击。以下是示例代码:

    class Controller:
        # ... 其他代码 ...
    
        def start_keyboard_press_key(self):
            for key, interval in key_time_dict.items():
                if key in pyautogui.KEYBOARD_KEYS:
                    print("启动线程, 按键: ", key, " 间隔: ", interval)
                    t = threading.Thread(target=self.press_key, args=(key, interval))
                    t.daemon = True
                    t.start()
                else:
                    print(f"Key: {key} is not a valid key")
    
        def press_key(self, key, interval):
            print("按键: ", key, " 间隔: ", interval)
            while True:
                if self.keyboard_stop_flag:
                    break
                pyautogui.press(key)
                time.sleep(interval)
    
        def start_mouse_auto_click_key(self, status):
            print("启动鼠标自动点击线程... ")
            if status == self.MOUSE_STATUS_CLICK:
                print(f"鼠标自动点击... delay:{window.mouseDelay.value()}")
                delay = window.mouseDelay
    
    .value()
                t = threading.Thread(target=self.mouse_click, args=(delay,))
                t.daemon = True
                t.start()
            elif status == self.MOUSE_STATUS_PRESS:
                print("鼠标长按... ")
                mouseC = mouse.Controller()
                pyautogui.mouseDown()
                t = threading.Thread(target=self.mouse_press)
                t.daemon = True
                t.start()
    
        def mouse_click(self, interval):
            print("鼠标自动点击, 间隔: ", interval)
            while True:
                if self.mouse_auto_stop_flag:
                    break
                # 获取鼠标当前位置
                print("指定的坐标... {}, {}".format(mouseX, mouseY))
                if mouseX == 0 and mouseY == 0:
                    mouseXx, mouseYy = pyautogui.position()
                else:
                    mouseXx = mouseX
                    mouseYy = mouseY
                pyautogui.click(int(mouseXx), int(mouseYy))
                time.sleep(interval)
    
        def mouse_press(self):
            print("开启鼠标长按... ")
            while True:
                if self.mouse_auto_stop_flag:
                    # 释放鼠标左键并退出循环
                    pyautogui.mouseUp()
                    print("鼠标长按结束")
                    break
                print("鼠标长按中... ")
                time.sleep(0.3)

    这个部分的代码用于启动键盘按键模拟和鼠标点击操作。根据用户的设置,它可以实现自动点击、长按和模拟按键等功能。

    6. 启动监听器

    最后,我们需要启动监听器来监控键盘和鼠标事件。我们在主程序中创建了一个start_listener函数,该函数启动了监听键盘和鼠标事件的线程。以下是示例代码:

    def start_listener():
        game_title = "Your Game Title"  # 替换为你的游戏窗口标题
        global controller
        controller = Controller()
        # 启动一个守护线程
        print("启动线程监听...")
        daemon = threading.Thread(target=keyboard_listener, args=(controller,))
        daemon.daemon = True
        daemon.start()
        daemon = threading.Thread(target=mouse_listener, args=(controller,))
        daemon.daemon = True
        daemon.start()
    
    def keyboard_listener(args):
        print("启动线程监听键盘...")
        controller = args
        with keyboard.Listener(
                on_press=controller.on_press,
                on_release=controller.on_release) as listener:
            listener.join()
    
    def mouse_listener(args):
        print("启动线程监听鼠标...")
        controller = args
        with mouse.Listener(
                on_click=controller.on_mouse_press,
                on_release=controller.on_mouse_release) as listener:
            listener.join()

    通过这些代码,我们可以启动监听器来监控键盘和鼠标事件,然后根据用户的设置执行相应的自动化操作。

    7. 总结

    通过创建一个自动化按键和鼠标点击工具,你可以轻松地执行重复性的操作,提高工作效率。这个工具可以用于各种应用场景,包括游戏、自动化测试、数据录入等。希望本教程对你有所帮助,让你更好地掌握自动化操作的技巧。

  • 如何刷机并安装OpenWrt系统到360 T7路由器

    嗨,各位技术达人!你是否曾想过将你的360 T7路由器升级到更强大的OpenWrt系统,以获得更多的功能和性能?如果是的话,你来对地方了。本文将为你详细介绍如何刷机并安装OpenWrt系统到你的360 T7路由器,让你充分释放这个性价比极高的设备的潜力。

    第一步:准备工作

    在开始刷机之前,确保你已经准备好以下材料和条件:

    • 一台360 T7路由器
    • 一台运行Windows的电脑(需要有以太网插口)
    • USB转TTL模块(可以在淘宝等平台购买)
    • 一根公对母的杜邦线(用于连接TTL模块和路由器)
    • 下载好的OpenWrt固件

    第二步:开启Telnet

    开始之前,我们需要将路由器进入Telnet模式,这需要一些步骤:

    1. 打开360 T7路由器的底部,你会看到两颗螺丝,用螺丝刀将它们拧下来。注意:底盖可能会有很多卡扣,需要用力打开。
    2. 打开底部后,你会看到TTL串口,上面有RXD、TXD、GND三个引脚。使用杜邦线将这些引脚连接到TTL模块(路由器的RXD连接到模块的TXD,路由器的TXD连接到模块的RXD,GND连接到GND)。
    3. 使用串口调试助手(如Termius)连接到TTL模块,选择正确的COM口和波特率115200,然后连接。

    现在,你将能够看到路由器的开机日志输出。接下来,我们将进入Failsafe模式,输入"f"(需要回车换行)并观察日志,直到看到成功进入Failsafe模式的信息。

    第三步:刷入U-Boot

    在Failsafe模式下,你可以输入以下命令来刷入U-Boot:

    fw_setenv bootmenu_delay 3
    mount_root
    sed -i 's/.*local debug=.*/\tlocal debug=1/' /etc/init.d/telnet
    passwd root
    # 输入两次相同的密码
    password
    password
    reboot

    这些命令的作用是开启U-Boot控制台菜单、挂载rootfs并开启Telnet,然后修改root密码并重启路由器。

    第四步:刷入U-Boot并安装OpenWrt

    重启后,你将能够正常配置你的路由器。现在,你可以通过Telnet连接到路由器的U-Boot界面,并使用以下命令来刷入U-Boot并安装OpenWrt:

    cd /tmp
    wget https://sebs.oss-cn-shanghai.aliyuncs.com/360t7-fip-fixed-parts.bin
    mtd write 360t7-fip-fixed-parts.bin fip

    刷入U-Boot后,路由器将自动重启并进入新的OpenWrt固件。你可以重新安装好底盖并开始享受OpenWrt系统的强大功能。

    第五步:配置OpenWrt

    要配置OpenWrt系统,你可以通过浏览器访问默认的后台地址:192.168.6.1。默认的用户名是root,密码是你之前设置的密码(在刷U-Boot时设置)。

    现在,你可以自由配置OpenWrt系统,包括Wi-Fi设置、网络配置、安全性等。

    性能测试

    你的360 T7现在已经刷入了OpenWrt系统,让我们看看它的性能表现:

    • CoreMark跑分:8803.7,显示CPU性能较好。
    • 科学性能:在合适的设置下,能够达到800Mbps以上的性能,这将满足大多数家庭的需求。
    • HWNAT硬件加速:能够轻松达到1000Mbps宽带,而CPU几乎不占用。

    无线信号也非常强大,能够在近距离和隔墙距离下提供快速稳定的连接。

    结语

    通过刷机并安装OpenWrt系统,你的360 T7路由器将获得更多功能和更强大的性能,让你充分发挥这个性价比极高的设备的潜力。虽然刷机需要一些技术操作,但遵循正确的步骤,你将能够成功完成并享受更好的路由器性能。

    希望这篇教程对你有所帮助。如果你有任何问题或需要更多帮助,请随时留言。

  • 解锁Google开发者账号:应对关联下架和封号的有效方法

    有一天,你突然发现自己的Google开发者账号被关联下架或封号了,这是许多开发者不愿面对的噩梦。Google Play作为全球最大的应用商店之一,确实为开发者提供了巨大的机会,但也伴随着严格的审查机制和风险。本文将探讨为什么你的开发者账号可能会被移除,并分享如何避免关联下架和封号的有效方法。

    第一步:上架流程

    首先,让我们回顾一下Google Play的上架流程。在这一步,你需要确保你的账号和应用信息是绝对干净的。这包括手机号、银行卡、网络环境等都不应该有关联。

    st=>start: 开始
    op1=>operation: 确保账号干净
    op2=>operation: 提交应用
    op3=>operation: 等待审查
    e=>end: 完成上架
    
    st->op1->op2->op3->e

    在这个过程中,你必须确保你的账号和应用信息都是绝对的清白,没有任何关联。

    第二步:关联下架问题

    关联下架是许多Google开发者都会面临的问题。你可能会收到类似这样的邮件:

    这封邮件通常是关联下架的模板邮件,一旦你的账号被关联,就会被封号下架,而且你可能无法得知具体的下架原因或提出申诉。

    为什么会被关联下架?

    账户关联是指Google Play认为你的多个应用可能是相似的或违反了开发者政策的情况。这可能是因为你的应用存在马甲包的情况,一旦被发现,就会导致所有应用被下架和封号。

    如果你只有一个应用上架,但出现了关联下架的情况,那么问题可能在于你的账号本身不够干净。在这种情况下,注册一个全新的开发者账号可能是最稳妥的方法。

    第三步:如何保证账号干净?

    要确保账号干净,你需要注意以下几个方面:

    1. 隐私链接:隐私链接要使用与违规账号不同的域名,并确保隐私链接内的联系方式与之前无关。

    2. 账号密码和辅助邮箱:每个开发者账号都应该有不同的密码,辅助邮箱也不应与违规账号有关。

    3. 素材图和宣传文案:商店素材图和宣传文案应定期更换,确保不要相似度太高。

    4. 应用名称/LOGO/UI:如果你的应用曾多次下架,务必更换应用名称、LOGO、UI等素材,避免与违规应用相似度过高。

    5. 后端接口:更换服务器的IP地址和域名,改变接口结构,加密数据传输,以防被关联。

    6. 客户端代码:代码混淆是确保客户端代码不容易被关联的关键。混淆的程度越高越好,确保代码结构、类名、方法名、变量名等都具有唯一性。

    st=>start: 开始
    op1=>operation: 更换隐私链接
    op2=>operation: 修改密码和辅助邮箱
    op3=>operation: 定期更新素材图和宣传文案
    op4=>operation: 更换应用名称/LOGO/UI
    op5=>operation: 更改后端接口
    op6=>operation: 提高代码混淆程度
    e=>end: 完成
    
    st->op1->op2->op3->op4->op5->op6->e

    这些步骤可以帮助你确保你的开发者账号和应用在Google Play上保持干净,降低被关联下架的风险。

    结论

    Google Play的上架过程是复杂的,而关联下架和封号是每个开发者都应该警惕的问题。为了避免这些问题,你需要保持账号和应用的绝对干净,定期更新关键信息,遵守Google Play的政策。谷歌的政策不断升级,我们必须与时俱进,以确保我们的应用能够长期留在平台上。

  • 解锁ChatGPT Plus:绕开OpenAI限制的全新方式

    有一天,你突然发现自己的ChatGPT Plus账号被OpenAI封禁了,或者付费被拒绝,无法再享受这一令人着迷的AI服务。别急,我们为你带来了一个全新的解决方案,让你可以继续畅享ChatGPT Plus的魅力。本文将详细介绍通过支付宝购买美区App Store礼品卡的方法,来绕开封号和支付限制,让你再次体验ChatGPT Plus的卓越功能。

    第一步:确认账号状态

    首先,让我们来确认你的ChatGPT账号是否处于被封禁或付费被取消的状态。如果你遇到以下情况之一,那么本文适用于你:

    • 当你尝试登录ChatGPT账号时,系统提示:“You do not have an account because it has been deleted or deactivated. If you believe this was an error, please contact us through our help center at help.openai.com。”

    • 你收到OpenAI的邮件,内容主要提到账号上出现可疑活动,为了保护平台安全,已经取消了你的ChatGPT Plus订阅。你将无法再访问ChatGPT Plus服务。邮件中还提到,如果你认为这是错误的操作,可以提交上诉以恢复你的账号。

    • 你尝试使用depay付费,但支付被拒绝,账号变为普通版。这可能意味着你的ChatGPT账号已被风控,需要采用新的续费方式,甚至注册新账号。

    第二步:注册新的ChatGPT账号

    如果你的账号没有被封禁,只是Plus付费被取消,请跳过此步骤。

    如果你的账号已被封禁,无法登录,你需要重新注册一个新的ChatGPT账号。

    第三步:注册美区Apple ID

    现在,你需要一个美区App Store账号。如果你还没有一个美区账号,可以参考以下两篇文章来注册账号并安装ChatGPT的iOS版本:

    1. 使用国内的App Store账号,将区域切换到美国。

    第四步:使用支付宝充值美区App Store

    为什么我们不建议在闲鱼上直接购买礼品卡呢?因为在闲鱼上购买的礼品卡很难验证是否合法,如果你使用非法的卡片进行充值,有很大可能会导致你的美区Apple ID账号被封禁。

    当你成功注册美区账号后,接下来就是使用支付宝购买美区App Store礼品卡,按照以下步骤进行操作:

    1. 将支付宝的地理位置切换到“旧金山”,激活美区App Store充值入口。

    2. 切换地理位置后,在页面下滑,找到App Store充值入口。

    3. 注册账号,并完成充值。请注意,你在注册时填写的邮箱将会收到App Store的激活码,请务必准确填写。此外,购买礼品卡的金额应大于20美元,因为ChatGPT Plus的月费是19.9美元。如果你直接购买20美元的礼品卡,可能会在后续步骤中遇到账户余额不足的问题。建议你充值25美元,以确保足够的余额。

    4. 付款完成后,登录时填写的邮箱将在大约2分钟内收到App Store激活码的邮件。如果没有收到,请检查你的垃圾邮件文件夹。

    5. 打开已登录美区账号的App Store,输入激活码。

    st=>start: 第一步:确认账号状态
    op=>operation: 如果账号被封禁或付费被取消
    op2=>operation: 如果账号未被封禁,只是付费被取消
    cond=>condition: 是否需要重新注册新的ChatGPT账号?
    op3=>operation: 第二步:注册新的ChatGPT账号
    op4=>operation: 第三步:注册美区Apple ID
    op5=>operation: 第四步:使用支付宝充值美区App Store
    op6=>operation: 第五步:ChatGPT Plus续费
    e=>end: 完成
    
    st->op->cond
    cond(yes)->op3
    cond(no)->op2
    op3->op4->op5->op6->e
    

    第五步:ChatGPT Plus续费

    在成功充值App Store余额后,现在可以在ChatGPT的iOS应用程序上续费Plus账户了。

    续费完成后,你可以在PC浏览器上登录ChatGPT账号,继续使用GPT-4版本。

    总结

    ChatGPT近日更新了风控规则,导致之前使用depay虚拟信用卡支付的账号大多被封禁或取消续费。本文提供了一个全新的方法,通过美区App Store购买礼品卡来支付Plus账户,希望这个方案可以帮助解决你的续费问题。如果你按照步骤仍然遇到问题,请在文章下方留言,我们将尽力提供帮助。

    希望这篇文章能帮助你解锁ChatGPT Plus,绕开OpenAI的限制,继续享受这一出色的AI服务。如果你有任何问题或需要进一步的帮助,请随时留言。

  • 让语言模型在你的计算机上运行代码:Open Interpreter

    你是否曾经梦想过拥有一个能够运行代码的助手,能够执行各种任务,从编辑照片、视频、PDF文件,到控制浏览器进行研究,再到绘制、清理和分析大型数据集?现在,这个梦想成真了!Open Interpreter是OpenAI的Code Interpreter的本地开源实现,它可以让语言模型在你的计算机上运行代码,为你提供一个自然语言界面,让你可以通过终端与它进行交互。在本文中,我们将探讨Open Interpreter的功能、用法以及与OpenAI的Code Interpreter的比较。

    开篇故事

    想象一下,你正在处理一个庞大的数据集,需要进行数据清理和分析。你不想编写大量的代码,也不想手动进行这些任务,因为这既费时又繁琐。然后,你听说了一种神奇的工具,可以让你用自然语言命令来完成这些任务。你迫不及待地想要尝试一下,看看它是否能够让你的工作事半功倍。这个神奇的工具就是Open Interpreter!

    什么是Open Interpreter?

    Open Interpreter是OpenAI的Code Interpreter的本地开源实现,它让你可以在你的计算机上运行代码。你可以使用自然语言与Open Interpreter进行交互,就像与ChatGPT一样,只需在安装后运行 $ interpreter 即可。Open Interpreter支持多种编程语言,包括Python、JavaScript、Shell等,这意味着你可以使用它执行各种任务,无需编写繁琐的代码。

    如何开始

    使用Open Interpreter非常简单。首先,你需要安装它,只需运行以下命令:

    pip install open-interpreter

    安装完成后,你可以在终端中运行以下命令来启动Open Interpreter:

    interpreter

    这将打开一个ChatGPT-like的界面,你可以在其中使用自然语言命令来与Open Interpreter进行交互。例如,你可以输入以下命令来执行一个任务:

    import interpreter
    
    interpreter.chat("绘制AAPL和META的归一化股价图")

    除了执行单个命令外,你还可以启动交互式对话,与Open Interpreter进行多轮交流。

    Open Interpreter与ChatGPT的Code Interpreter的比较

    尽管OpenAI发布的GPT-4搭载了Code Interpreter,但它有一些限制,例如无法访问互联网、预装的包有限、上传文件大小限制等。而Open Interpreter通过在你的本地环境上运行来克服这些限制。它可以访问互联网,没有时间或文件大小限制,并且可以使用任何包或库。这将GPT-4的Code Interpreter的强大功能与本地开发环境的灵活性相结合,为你提供了更广泛的应用可能性。

    高级用法

    除了基本的使用方法之外,Open Interpreter还提供了一些高级用法,以增强你的控制能力。以下是一些高级用法示例:

    • 保存和恢复对话: 你可以保存Open Interpreter的对话历史,然后在需要时恢复它。这对于长期项目或任务非常有用。
    # 保存对话
    messages = interpreter.chat("我的名字是小明。", return_messages=True)
    # 重置对话
    interpreter.reset()
    # 恢复对话
    interpreter.load(messages)
    • 自定义系统消息: 你可以自定义Open Interpreter的系统消息,以扩展其功能、修改权限或提供更多上下文信息。
    interpreter.system_message += """
    使用-y参数运行shell命令,以免用户确认。
    """
    • 切换模型: 如果需要,你可以切换Open Interpreter使用的模型。
    interpreter --fast

    以上只是一些高级用法的示例,Open Interpreter提供了丰富的配置选项,以满足不同场景下的需求。

    安全注意事项

    需要注意的是,由于生成的代码在你的本地环境中执行,它可以与你的文件和系统设置进行交互,潜在地导致意外的结果,如数据丢失或安全风险。因此,Open Interpreter在执行代码之前会要求你确认。你可以使用 interpreter -y 或设置 interpreter.auto_run = True 来跳过此确认,但在这种情况下,你需要格外谨慎,确保不会请求修改文件或系统设置的命令。

    结语

    Open Interpreter为开发者提供了一个强大的工具,让你可以使用自然语言来运行代码,执行各种任务,无需编写大量的代码。它的本地运行方式克服了许多云服务的限制,为你提供了更大的自由度和灵活性。无论是进行数据分析、自动化任务还是进行实验性编程,Open Interpreter都能够帮助你更轻松地实现目标。

    现在,你可以尝试安装Open Interpreter,并开始探索其强大的功能,看看它如何为你的项目带来便利和效率提升!

  • 如何使用虚构提示优化OpenAI的Whisper音频转录

    你是否曾经试图使用自动音频转录工具来转录音频文件,却发现它并没有理解你的音频或产生了一些拼写错误?OpenAI的Whisper音频转录API可以帮助你解决这些问题,并且可以根据虚构的提示来更好地理解音频内容。在这篇文章中,我们将探讨如何使用虚构的提示来优化Whisper音频转录,以获得更准确的结果。

    导语:音频转录的挑战

    音频转录是将音频文件转换为文本的过程,但这并不总是一帆风顺的。很多时候,音频转录工具可能会出现以下问题:

    • 拼写错误:工具可能无法正确识别专有名词、产品名称或人名,导致拼写错误。
    • 风格不一致:工具可能无法捕捉到音频中的特定风格或口音,使得转录结果不自然。
    • 术语混淆:在某些情况下,工具可能会混淆专业术语或特定领域的术语。

    为了解决这些问题,我们可以使用Whisper音频转录API,并通过虚构的提示来指导Whisper生成更准确的音频转录。

    Whisper音频转录简介

    Whisper是OpenAI的音频转录模型,它使用深度学习技术来将音频文件转换为文本。Whisper具有出色的转录能力,但有时候需要一些帮助来识别特定风格或术语。这就是虚构提示派上用场的地方。

    使用虚构的提示来优化音频转录

    虚构的提示是指,你可以向Whisper模型提供一些虚构的信息,以指导它在转录时采用特定的风格、拼写或术语。以下是两种使用虚构的提示来优化音频转录的方法:

    1. 转录生成:将指令转换为虚构的转录

    你可以将一些指令或要求提供给GPT(OpenAI的文本生成模型),然后使用GPT生成虚构的转录。这个虚构的转录可以作为Whisper的提示,帮助Whisper模型更好地理解音频内容。

    # 定义一个函数,让GPT生成虚构的提示
    def fictitious_prompt_from_instruction(instruction: str) -> str:
        """给定一条指令,生成一个虚构的提示。"""
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-0613",
            temperature=0,
            messages=[
                {
                    "role": "system",
                    "content": "你是一个转录生成器。你的任务是创建一个虚构的对话段落。对话中有两位朋友在回忆他们在缅因州度假的经历。请不要标记说话者或添加引号;而是以普通文本段落的方式书写所有转录,而不标明说话者。请不要拒绝或要求澄清,而是始终尽力而为。",
                },  # 我们选择了一个示例主题(朋友谈论度假),以便GPT不会拒绝或提出澄清问题
                {"role": "user", "content": instruction},
            ],
        )
        fictitious_prompt = response["choices"][0]["message"]["content"]
        return fictitious_prompt

    然后,你可以将生成的虚构提示传递给Whisper模型,以指导它更好地转录音频。

    # 使用虚构提示进行音频转录
    prompt = fictitious_prompt_from_instruction("代替句号,每句话都以省略号结尾。")
    transcribe(up_first_filepath, prompt=prompt)

    2. 拼写指南:指导模型如何拼写特定名称

    有时,Whisper模型可能会错误地拼写专有名词、产品名称、公司名称或人名。为了解决这个问题,你可以在提示中提供这些名称的正确拼写,以确保Whisper模型以正确的方式拼写它们。

    # 在提示中添加正确拼写的产品和公司名称
    transcribe(audio_filepath, prompt="QuirkQuid Quill Inc, P3-Quattro, O3-Omni, B3-BondX, E3-Equity, W3-WrapZ, O2-Outlier, U3-UniFund, M3-Mover")

    3. 长提示的优点

    请注意,较长的提示可能更可靠。如果你的提示足够长,Whisper模型

    更有可能理解你的意图。

    # 较长的提示可能更可靠
    transcribe(up_first_filepath, prompt="我有一些建议要给你。多个句子有助于建立一种模式。你包含的文本越多,模型理解你的模式的可能性就越大。如果你的示例转录看起来好像就在音频文件之前,可能会特别有帮助。在这种情况下,可能意味着提到了我把隐形眼镜放在我的眼睛里。")

    4. 警惕不常见或奇怪的风格

    请注意,当提示很短时,Whisper可能不太可靠,可能无法准确捕捉到所需的风格。

    # 短提示可能不太可靠
    transcribe(up_first_filepath, prompt="总统拜登。")

    5. 风格不常见的提示

    如果你的提示要求Whisper采用不常见的风格,Whisper可能不太可靠。

    # 风格不常见的提示可能不太可靠
    transcribe(up_first_filepath, prompt="""嗨,欢迎来到节目。
    ###
    今天我们非常兴奋。
    ###
    让我们马上开始。
    ###""")

    通过以上方法,你可以根据需要引导Whisper模型,以获得更准确、一致和风格符合预期的音频转录结果。

    Whisper提示与GPT提示的比较

    需要注意的是,Whisper提示与GPT提示不同。如果你提交了一个类似于“在Markdown格式中格式化列表”的尝试性指令,Whisper模型不会执行这个指令,因为它会遵循提示的风格,而不是其中包含的任何指令。

    另外,提示的长度受到限制,只能包含224个标记。如果提示的长度超过224个标记,只有提示的最后224个标记将被考虑;之前的标记将被忽略。

    为了获得最佳结果,请精心制作可以表达你所需风格的示例。

    结论

    使用虚构的提示来优化OpenAI的Whisper音频转录是一个强大的工具,可以帮助你获得更准确、一致和风格符合预期的音频转录结果。无论你是在为广播节目制作转录、记录会议或进行研究,Whisper API都可以成为提高生产力的有力工具。

    现在,尝试使用虚构的提示来优化你的音频转录,看看它如何帮助你获得更好的结果!

  • 如何使用DALL·E API:创建惊艳图像的秘诀

    注意:本文将教你如何使用OpenAI的DALL·E图像API,但请确保你已经获得了相应的API访问权限。

    你是否曾经想过能够通过简单的文字描述生成令人惊艳的图像?OpenAI的DALL·E图像API为你提供了这个机会。本文将向你展示如何使用DALL·E API的三个关键端点:生成、编辑和变化,以及一些有用的提示和技巧。

    开场故事

    想象一下,你是一名创意设计师,你的任务是为一家时尚杂志创建独特的封面图像。你需要一种方法来将你的创意快速转化为视觉艺术,而不需要繁琐的图像编辑工作。幸运的是,有一种新颖的技术可以帮助你实现这一目标,那就是使用DALL·E API。在本文中,我们将探讨如何使用这个API来生成、编辑和变换图像,让你的创意得以充分展示。

    准备工作

    在开始之前,你需要完成一些准备工作。

    导入必要的库

    首先,导入你需要的Python库。这些库将帮助你与DALL·E API进行交互,并进行图像处理。

    import openai  # OpenAI Python库,用于进行API调用
    import requests  # 用于下载图像
    import os  # 用于访问文件路径
    from PIL import Image  # 用于显示和编辑图像

    设置API密钥

    在继续之前,确保你已经获取了OpenAI的API密钥,并将其设置为环境变量。你可以在终端中运行以下命令来设置API密钥:

    export OPENAI_API_KEY="你的API密钥"

    设置保存图像的目录

    为了保存生成的图像,创建一个目录,以便后续使用。你可以使用以下代码来创建目录:

    # 设置保存DALL·E图像的目录
    image_dir_name = "images"
    image_dir = os.path.join(os.curdir, image_dir_name)
    
    # 如果目录不存在,则创建它
    if not os.path.isdir(image_dir):
        os.mkdir(image_dir)

    使用DALL·E API

    现在,让我们深入了解如何使用DALL·E API的不同端点来生成、编辑和变换图像。

    生成图像

    生成端点用于根据文本描述生成图像。你只需提供一个文本描述,DALL·E就会尝试创建相应的图像。

    必要输入:

    • prompt(str):对所需图像的文本描述。最大长度为1000个字符。

    可选输入:

    • n(int):要生成的图像数量。必须介于1和10之间,默认为1。
    • size(str):生成图像的尺寸。必须是以下尺寸之一:"256×256"、"512×512"或"1024×1024"。较小的图像生成速度更快,默认为"1024×1024"。
    • response_format(str):生成的图像返回格式。必须是"url"或"b64_json"之一,默认为"url"。
    • user(str):代表你的最终用户的唯一标识符,有助于OpenAI监测和检测滥用。了解更多信息。

    让我们看看如何使用DALL·E API生成图像的示例:

    # 设置文本描述
    prompt = "一个赛博朋克的猴子黑客,梦想着一堆美味的香蕉,数字艺术"
    
    # 调用OpenAI API
    generation_response = openai.Image.create(
        prompt=prompt,
        n=1,
        size="1024x1024",
        response_format="url",
    )
    
    # 打印响应
    print(generation_response)

    上述代码将返回生成的图像的URL。你可以将这个URL用于下载图像,如下所示:

    # 保存图像
    generated_image_name = "生成的图像.png"  # 任何你喜欢的名称,文件类型应为.png
    generated_image_filepath = os.path.join(image_dir, generated_image_name)
    generated_image_url = generation_response["data"][0]["url"]  # 从响应中提取图像URL
    generated_image = requests.get(generated_image_url).content  # 下载图像
    
    with open(generated_image_filepath, "wb") as image_file:
        image_file.write(generated_image)  # 将图像写入文件

    接下来,我们可以使用PIL库来显示生成的图像:

    # 显示生成的图像
    print(generated_image_filepath)
    Image.open(generated_image_filepath)

    变换图像

    变换端点用于生成与输入图像相似的新图像(变体)。

    必要输入:

    • image(str):要用作变体基础的图像。必须是有效的PNG文件,小于4MB,并且是正方形。

    可选输入:

    • n(int):要生成的图像数量。必须介于1和10之间,默认为1。
    • size(str):生成图像的尺寸。必须是以下尺寸之一:"256×256"、"512×512"或"1024×1024"。较小的图像生成速度更快,默认为"1024×1024"。
    • response_format(str):生成的图像返回格式。必须是"url"或"b64_json"之一,默认为"url"。
    • user(str):代表你的最终用户的唯一标识符,

    有助于OpenAI监测和检测滥用。了解更多信息。

    以下是如何生成图像变体的示例:

    # 调用OpenAI API,使用`create_variation`而不是`create`
    variation_response = openai.Image.create_variation(
        image=generated_image,  # 从上面生成的图像获取
        n=2,
        size="1024x1024",
        response_format="url",
    )
    
    # 打印响应
    print(variation_response)

    类似于生成图像,我们可以将变体的URL用于下载图像,如下所示:

    # 保存变体图像
    variation_urls = [datum["url"] for datum in variation_response["data"]]  # 提取URL
    variation_images = [requests.get(url).content for url in variation_urls]  # 下载图像
    variation_image_names = [f"变体图像_{i}.png" for i in range(len(variation_images))]  # 创建名称
    variation_image_filepaths = [os.path.join(image_dir, name) for name in variation_image_names]  # 创建文件路径
    for image, filepath in zip(variation_images, variation_image_filepaths):  # 遍历变体
        with open(filepath, "wb") as image_file:  # 打开文件
            image_file.write(image)  # 将图像写入文件

    接下来,我们可以使用PIL库来显示生成的原始图像和变体图像:

    # 显示原始图像
    print(generated_image_filepath)
    Image.open(generated_image_filepath)
    
    # 显示新的变体图像
    for variation_image_filepaths in variation_image_filepaths:
        print(variation_image_filepaths)
        Image.open(variation_image_filepaths)

    编辑图像

    编辑端点使用DALL·E生成现有图像的指定部分。编辑需要三个输入:要编辑的图像、指定要重新生成的部分的蒙版和描述所需图像的提示。

    必要输入:

    • image(str):要编辑的图像。必须是有效的PNG文件,小于4MB,并且是正方形。
    • mask(str):另一个图像,其完全透明区域(例如,alpha为零的区域)指示图像应该进行编辑。必须是有效的PNG文件,小于4MB,并且与图像具有相同的尺寸。
    • prompt(str):对所需图像的文本描述。最大长度为1000个字符。

    可选输入:

    • n(int):要生成的图像数量。必须介于1和10之间,默认为1。
    • size(str):生成图像的尺寸。必须是以下尺寸之一:"256×256"、"512×512"或"1024×1024"。较小的图像生成速度更快,默认为"1024×1024"。
    • response_format(str):生成的图像返回格式。必须是"url"或"b64_json"之一,默认为"url"。
    • user(str):代表你的最终用户的唯一标识符,有助于OpenAI监测和检测滥用。了解更多信息。

    编辑需要一个“蒙版”,以指定图像的哪个部分需要重新生成。蒙版是一个图像,其中alpha值为0(透明)的任何像素都将重新生成。下面的代码创建一个1024×1024的蒙版,其中底半部分是透明的:

    # 创建一个蒙版
    width = 1024
    height = 1024
    mask = Image.new("RGBA", (width, height), (0, 0, 0, 1))  # 创建一个不透明的图像蒙版
    
    # 将底半部分设置为透明
    for x in range(width):
        for y in range(height // 2, height):  # 仅循环遍历蒙版的底半部分
            # 将alpha(A)设置为零以使像素变为透明
            alpha = 0
            mask.putpixel((x, y), (0, 0, 0, alpha))
    
    # 保存蒙版
    mask_name = "底半部分蒙版.png"
    mask_filepath = os.path.join(image_dir, mask_name)
    mask.save(mask_filepath)

    现在,我们可以使用这个蒙版来编辑图像,生成一些编辑的示例:

    # 编辑图像
    
    # 调用OpenAI API
    edit_response = openai.Image.create_edit(
        image=open(generated_image_filepath, "rb"),  # 来自生成部分的图像
        mask=open(mask_filepath, "rb"),  # 来自上面的蒙版
        prompt=prompt,  # 来自生成部分的文本描述
        n=1,
        size="1024x1024",
        response_format="url",
    )
    
    # 打印响应
    print(edit_response)

    与前面的示例一样,我们可以将编辑的图像的URL用于下载图像,如下所示:

    # 保存图像
    edited_image_name = "编辑后的图像.png"  # 任何你喜欢的名称,文件类型应为.png
    edited_image_filepath = os.path.join(image_dir, edited_image_name)
    edited_image_url = edit_response["data"][0]["url"]  # 从响应中提取图像URL
    edited_image = requests.get(edited_image_url).content  # 下载图像
    
    with open(edited_image_filepath, "wb") as image_file:
        image_file.write(edited_image)  # 将图像写入文件

    现在,我们可以使用PIL库来显示原始图像和编辑后的图像:

    # 显示原始图像
    print(generated_image_filepath)
    Image.open(generated_image_filepath)
    
    # 显示编辑后的图像
    print(edited_image_filepath)
    Image.open(edited_image_filepath)

    小贴士

    在使用DALL·E API时,以下是一些有用的小贴士:

    • 尝试不同的文本描述:通过尝试不同的文本描述来获得不同风格和主题的图像。
    • **实验编辑

    **:尝试使用不同的蒙版和文本描述来编辑图像,以获得不同的效果。

    • 注意图像尺寸:选择适合你项目需要的图像尺寸,较小的图像生成速度更快。
    • 保留API密钥安全:确保不分享你的API密钥,以防止滥用。

    现在,你已经了解如何使用DALL·E API生成、编辑和变换图像,你可以尝试将这些技巧应用到你的创意项目中,为你的设计工作增添一些魔法。

    结论

    DALL·E API为创意设计师和艺术家提供了一个令人兴奋的机会,可以通过简单的文本描述来生成、编辑和变换惊艳的图像。无论你是在制作杂志封面、广告宣传、艺术作品还是任何其他创意项目,DALL·E API都可以成为你的得力助手。

    现在,赶快尝试一下这个令人着迷的技术,看看它如何为你的创意世界带来新的可能性!

  • 创建自动化试卷生成工具:使用Python和OpenPyXL

    你是否曾经需要为学生创建大量的试卷,但又不想手动编写每一份试卷?在这个教程中,我们将使用Python编写一个自动化试卷生成工具,可以根据题库随机生成试卷,并保存为Word文档。无需编程经验,我们将一步步引导你完成整个过程。

    开场故事

    假设你是一名教师,每学期都需要为你的学生创建多份试卷。但是,手动编写每一份试卷非常耗时且容易出错。你希望有一种自动化工具,可以根据题库随机生成试卷,以节省时间并降低错误率。现在,让我向你介绍如何使用Python创建这样一个自动化试卷生成工具。

    准备工作

    在开始之前,确保你的计算机上已经安装了以下工具和库:

    • Python:确保你已经安装了Python。如果没有,你可以从Python官方网站下载并安装。

    • OpenPyXL:OpenPyXL是一个用于操作Excel文件的Python库。你可以使用以下命令安装它:

      pip install openpyxl

    创建自动化试卷生成工具

    现在,让我们开始创建自动化试卷生成工具。

    导入必要的库

    首先,我们需要导入必要的Python库和模块。这些库包括random(用于生成随机数)和openpyxl(用于操作Excel文件)。

    import random
    from openpyxl import load_workbook

    创建随机数生成函数

    我们将创建一个函数,用于生成不重复的随机整数。这个函数将接受两个参数,分别是最大数和需要生成的随机数的个数。

    def Random_num(num_max, num_qty):
        num_list = []
        while len(num_list) < num_qty:
            num = random.randint(2, num_max)
            if num in num_list:
                continue
            else:
                num_list.append(num)
        return num_list

    创建题目抽取函数

    接下来,我们将创建一个函数,用于根据随机生成的题目编号从题库中抽取题目。这个函数将接受两个参数,分别是试题类型和需要抽取的试题编号。

    def Question(que_type, numbers):
        questions = []
        wb = load_workbook("题库.xlsx")
        ws = wb[que_type]
    
        for i in numbers:
            question = ws["B" + str(i)].value
            if que_type == "多选题" and ws["G" + str(i)].value:
                answerE = "E:\t" + str(ws["G" + str(i)].value)
                single_question = [question, answerE]
            else:
                single_question = [question]
            questions.append(single_question)
    
        return questions

    创建试卷生成函数

    现在,我们将创建一个函数,用于将抽取的试题写入Word文档中。

    from docx import Document
    from docx.shared import Pt
    from docx.oxml.ns import qn
    
    def To_word(number, questions_data):
        doc = Document("试题-模板.docx")
    
        title1 = "一、单项选择题(共40题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title1)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["单选题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
        title2 = "二、多项选择题(共20题,每题2分)"
        p = doc.add_paragraph()
        r = p.add_run(title2)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["多选题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
            if len(i) == 2:  # 判断是否有E选项
                doc.add_paragraph(f"{i[1]}")
    
        title3 = "三、判断题(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title3)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["判断题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
        title4 = "四、填空题(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title4)
        r.bold = True
        r.font.size = Pt(12)
    
        for index, i in enumerate(questions_data["填空题"], start=1):
            doc.add_paragraph(f"{index}. {i[0]}")
    
        doc.save(f"试卷及答案\\考试题{number}.docx")

    创建答案生成函数

    接下来,我们将创建一个函数,用于生成试题答案,并将答案写入Word文档中。

    def Answer(number, questions_data):
        doc = Document()
    
        title = "计算机系2020第二学期期末考试题(答案)"
        p = doc.add_paragraph()
        r = p.add_run(title)
        r.bold = True
        r.font.size = Pt(20)
    
        title1 = "一、单项选择题答案(共40题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title1)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["单选题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t")
            if index % 10 == 0:
                p = doc.add_paragraph()
    
        title2 = "二、多项选择题答案(
    
    共20题,每题2分)"
        p = doc.add_paragraph()
        r = p.add_run(title2)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["多选题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t")
            if index % 3 == 0:
                p = doc.add_paragraph()
    
        title3 = "三、判断题答案(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title3)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["判断题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t")
            if index % 5 == 0:
                p = doc.add_paragraph()
    
        title4 = "四、填空题答案(共10题,每题1分)"
        p = doc.add_paragraph()
        r = p.add_run(title4)
        r.bold = True
        r.font.size = Pt(12)
    
        p = doc.add_paragraph()
        for index, i in enumerate(questions_data["填空题"], start=1):
            p.add_run(f"{index}. {i[0]} {i[1]}\t\t")
            if index % 2 == 0:
                p = doc.add_paragraph()
    
        doc.save(f"试卷及答案\\考试题{number}答案.docx")

    主函数

    最后,我们创建了主函数来运行整个试卷生成过程。

    if __name__ == '__main__':
        for number in range(1, 21):  # 生成20套试卷
            num_single_choice = Random_num(566, 40)
            num_mult_choice = Random_num(196, 20)
            num_judgment = Random_num(418, 10)
            num_completion = Random_num(190, 10)
    
            question_num = {
                "单选题号": num_single_choice,
                "多选题号": num_mult_choice,
                "判断题号": num_judgment,
                "填空题号": num_completion
            }
    
            questions_data = {
                "单选题": Question("单选题", question_num["单选题号"]),
                "多选题": Question("多选题", question_num["多选题号"]),
                "判断题": Question("判断题", question_num["判断题号"]),
                "填空题": Question("填空题", question_num["填空题号"])
            }
    
            To_word(number, questions_data)
            Answer(number, questions_data)
            print(f"试卷{number}及答案生成完成!")

    运行试卷生成工具

    现在,你已经创建了一个自动化试卷生成工具,可以根据题库随机生成试卷,并将试卷和答案保存为Word文档。要运行工具,只需运行上述代码。生成的试卷和答案将保存在指定的文件夹中。

    总结

    通过本教程,你学会了如何使用Python和OpenPyXL创建一个自动化试卷生成工具。这个工具可以大大节省教师编写试卷的时间,同时降低了人为错误的风险。你可以根据自己的需求进一步扩展这个工具,添加更多功能,如生成不同类型的试题或自定义试题模板。

    希望这个教程对你有所帮助,让你更轻松地处理大量试卷生成工作!

  • 制作一个二维码识别工具:使用Python和PyQt5

    你是否曾经想过制作一个简单的二维码识别工具,让你能够通过摄像头捕捉二维码并获取其中的信息?如果是的话,那么你来对地方了!在本教程中,我们将使用Python和PyQt5创建一个简单的二维码识别工具。无需担心编程经验,我们将逐步引导你完成整个过程。

    准备工作

    在开始之前,确保你的计算机上已经安装了以下工具和库:

    • Python:确保你已经安装了Python。如果没有,你可以从Python官方网站下载并安装。

    • PyQt5:PyQt5是一个用于创建GUI应用程序的Python库。你可以使用以下命令安装它:

      pip install PyQt5
    • OpenCV:OpenCV是一个计算机视觉库,用于处理图像和视频。你可以使用以下命令安装它:

      pip install opencv-python
    • pyzbar:pyzbar是一个用于解码二维码的库。你可以使用以下命令安装它:

      pip install pyzbar

    创建二维码识别工具

    现在,让我们开始创建我们的二维码识别工具。

    导入必要的库

    首先,我们需要导入必要的Python库和模块。这些库包括PyQt5、OpenCV和pyzbar。此外,我们还需要一些其他的库来帮助我们管理图形用户界面(GUI)。

    import cv2
    from PIL import Image
    from pyzbar.pyzbar import decode
    import sys
    from PyQt5.QtWidgets import QApplication, QWidget, QTextEdit, QLabel, QGridLayout, QMessageBox
    from PyQt5.QtCore import QTimer, QCoreApplication

    创建GUI

    接下来,我们将创建一个简单的GUI,用于显示摄像头捕捉的图像以及解码后的二维码信息。

    class MyQRRec(QWidget):
        def __init__(self):
            super().__init__()
            self.initUI()
    
        def initUI(self):
            self.setGeometry(300, 200, 850, 650)
            self.setWindowTitle('二维码识别')
            grid = QGridLayout()
            self.setLayout(grid)
            grid.setSpacing(10)
    
            titleEdit = QTextEdit()
            titlePrompt = QLabel('把二维码放在摄像头前面:')
            grid.addWidget(titlePrompt, 1, 1)
            grid.addWidget(titleEdit, 2, 1)
    
            self.show()

    在上述代码中,我们创建了一个名为MyQRRec的QWidget子类,该子类用于显示GUI界面。我们使用QGridLayout来管理界面布局,并在界面上添加了一个用于显示解码后信息的文本框。

    捕捉摄像头图像

    现在,让我们添加代码来捕捉摄像头的图像并进行二维码识别。

    class MyQRRec(QWidget):
        # ...(之前的代码)
    
        def start_camera(self):
            self.cap = cv2.VideoCapture(0)
    
            cv2.namedWindow('Camera Feed')
            while not isExit:
                ret, frame = self.cap.read()
                frame = cv2.flip(frame, 1)
    
                cv2.imshow('Camera Feed', frame)
                x = decode(frame)
                app.processEvents()
                if x:
                    y = x[0].data.decode()
                    if y != lastResult:
                        titleEdit.setPlainText(titleEdit.toPlainText() + y)
                        lastResult = y
    
            self.cap.release()
            cv2.destroyAllWindows()
            sys.exit()
            QCoreApplication.instance().quit
    
        # ...(之后的代码)

    在上述代码中,我们创建了一个名为start_camera的方法,该方法用于启动摄像头并捕捉图像。我们使用OpenCV来访问摄像头,并在窗口中显示摄像头捕捉的图像。然后,我们使用pyzbar来解码图像中的二维码,并将解码结果显示在GUI的文本框中。

    关闭应用程序

    最后,我们需要添加代码来关闭应用程序。

    class MyQRRec(QWidget):
        # ...(之前的代码)
    
        def closeEvent(self, event):
            global isExit
            isExit = True

    在上述代码中,我们创建了一个名为closeEvent的方法,该方法在关闭应用程序时被调用,它将全局变量isExit设置为True,以停止摄像头捕捉。

    主函数

    最后,我们创建了主函数来运行应用程序。

    if __name__ == '__main__':
        app = QApplication(sys.argv)
        w = MyQRRec()
        sys.exit(app.exec_())

    运行二维码识别工具

    现在,你已经创建了一个简单的二维码识别工具,可以通过摄像头捕捉二维码并显示其内容。要运行应用程序,只需运行上述代码。

    总结

    通过本教程,你学会了如何使用Python和PyQt5创建一个简单的二维码识别工具。这个工具可以捕捉摄像头的图像,识别二维码,并显示其内容。你可以进一步扩展这个工具,添加更多功能,如保存识别的二维码图片或将识别结果保存到文件中。

    希望这个教程能帮助你开始使用Python和PyQt5创建自己的图形用户界面应用程序。祝你好运!