Python代码 第7页

这段代码使用了Selenium、requests和BeautifulSoup来爬取歌曲的下载链接和歌词，并将它们下载到本地。代码涵盖了以下主要步骤：

1. 使用Selenium创建一个无头Chrome浏览器，模拟用户点击页面上的按钮，从而获取歌曲的下载链接和歌词下载链接。
2. 使用requests库发送HTTP请求，从网页中获取歌曲的下载链接和歌词下载链接。
3. 创建文件夹用于保存下载的歌曲和歌词，如果文件夹不存在则创建。
4. 使用requests库下载歌曲和歌词，将它们保存到本地文件夹中。
5. 主方法中首先发送请求获取歌曲列表页面的内容，然后解析页面内容获取歌曲的下载链接和标题。最后，调用get_contents函数下载歌曲和歌词。

请注意，使用Selenium和requests等库进行网络爬取时，需要遵守网站的使用规则和法律法规。在爬取网站数据之前，请查阅网站的robots.txt文件以了解是否允许爬取，以及是否有反爬措施。在实际使用中，建议合理设置请求头、使用代理IP等手段来降低被封IP的风险。

from selenium import webdriver
import requests
from bs4 import BeautifulSoup
import os
options = webdriver.ChromeOptions()
options.add_argument('--headless')
# 给请求指定一个请求头来模拟chrome浏览器
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36',
    'cookie':'__51uvsct__JZKGLNhr7gNTmF1z=1; __51vcke__JZKGLNhr7gNTmF1z=dbcc8135-b908-58b9-ab0f-f09772cc8ef9; __51vuft__JZKGLNhr7gNTmF1z=1673170099915; __vtins__JZKGLNhr7gNTmF1z=%7B%22sid%22%3A%20%2250340dc9-526b-5b41-8642-2fa520c011a5%22%2C%20%22vd%22%3A%2030%2C%20%22stt%22%3A%204104371%2C%20%22dr%22%3A%20616811%2C%20%22expires%22%3A%201673176004282%2C%20%22ct%22%3A%201673174204282%7D'
}
server = 'https://www.gequbao.com'
# 凤凰传奇地址
singer = 'https://www.gequbao.com/s/%E8%B4%B9%E7%8E%89%E6%B8%85'
 
 
# 获取歌曲内容
def get_contents(song,song_title,singer_name):
    # print(song)
    save_url = 'G:/python/songs/{}'.format(singer_name)
    save_lrc_path = 'G:/python/songs/{}/{}.lrc'.format(singer_name,song_title)
    res = requests.get(url=song, headers=headers)
    res.encoding = 'utf-8'
    html = res.text
    soup = BeautifulSoup(html, 'html.parser')
    # 获取歌曲的下载链接
    driver = webdriver.Chrome(options=options)
    driver.get(song)
 
    song_elem = driver.find_element_by_id("btn-download-mp3")
    lrc_elem = driver.find_element_by_id("btn-download-lrc")
    download_url = song_elem.get_attribute('href')
    lrc_url = lrc_elem.get_attribute('href')
    # 读取MP3资源
    req = requests.get(download_url, stream=True)
    # 文件夹不存在，则创建文件夹
    folder = os.path.exists(save_url)
    if not folder:
        os.makedirs(save_url)
 
    # 文件存储地址
    full_title = song_title + '.mp3'
    file_path = os.path.join(save_url, full_title)
    print('开始写入歌曲：', file_path)
    # 打开本地文件夹路径file_path，以二进制流方式写入，保存到本地
    with open(file_path, 'wb') as fd:
        for chunk in req.iter_content():
            fd.write(chunk)
    print(song_title + '成功下载！')
    # 下载歌词
    print('开始写入歌词：', save_lrc_path)
    r = requests.get(lrc_url).content
    with open(save_lrc_path, 'wb') as fd:
        fd.write(r)
        fd.close()
    print(song_title + '歌词成功下载！')
 
 
# 主方法
def main():
    res = requests.get(singer, headers=headers)
    res.encoding = 'utf-8'
    html = res.text
    # 使用自带的html.parser解析
    soup = BeautifulSoup(html, 'html.parser')
    # 获取歌曲的列表
    songs = soup.find('div', class_='card-text').find_all(class_='text-primary')
    singer_name = soup.find('input', id='s-input-line')['value']
    print('查询到歌曲数: %d ' % len(songs))
    for each in songs:
        try:
            song = server + each.get('href')
            song_title = each.get_text().strip()
            get_contents(song,song_title,singer_name)
        except Exception as e:
            print(e)
 
 
if __name__ == '__main__':
    main()

这段代码是一个简单的学生信息管理系统，可以进行学生信息的录入、查找、删除、修改、排序、统计和显示等操作。主要的功能如下：

1. 录入学生信息：通过逐步输入学生的ID、名字以及英语、Python、C语言成绩，将学生信息保存到文件中。
2. 查找学生信息：可以按照学生ID或姓名查找学生信息，并将查询结果显示出来。
3. 删除学生信息：根据输入的学生ID，可以删除指定学生的信息。
4. 修改学生信息：可以根据输入的学生ID，修改学生的姓名以及英语、Python、C语言成绩。
5. 排序：可以按照英语、Python、C语言成绩以及总成绩进行升序或降序排序，并将排序结果显示出来。
6. 统计学生总数：统计当前录入的学生总人数。
7. 显示所有学生信息：显示当前保存在文件中的所有学生信息。

代码采用了面向过程的编程风格，使用了字典和列表来存储学生信息。每个功能都通过函数来实现，主函数main()在一个循环中显示菜单，并根据用户输入调用相应的函数。

如果要运行这段代码，需要保证文件名为students.txt的文本文件在同一目录下，因为代码会将学生信息保存在这个文件中。你可以根据需要进行代码的调整和优化，例如添加异常处理、增加更多的信息字段等。

# _*_ coding:utf-8   _*_
import re  # 导入正则表达式模块
import os  # 导入操作系统模块
 
filename = "students.txt"  # 定义保存学生信息的文件名
 
 
def menu():
    # 输出菜单
    print('''
    ╔———————学生信息管理系统————————╗
    │                                              │
    │   =============== 功能菜单 ===============   │
    │                                              │
    │   1 录入学生信息                             │
    │   2 查找学生信息                             │
    │   3 删除学生信息                             │
    │   4 修改学生信息                             │
    │   5 排序                                     │
    │   6 统计学生总人数                           │
    │   7 显示所有学生信息                         │
    │   0 退出系统                                 │
    │  ==========================================  │
    │  说明：通过数字或↑↓方向键选择菜单          │
    ╚———————————————————————╝
    ''')
 
 
def main():
    ctrl = True  # 标记是否退出系统
    while (ctrl):
        menu()  # 显示菜单
        option = input("请选择：")  # 选择菜单项
        option_str = re.sub("\D", "", option)  # 提取数字
        if option_str in ['0', '1', '2', '3', '4', '5', '6', '7']:
            option_int = int(option_str)
            if option_int == 0:  # 退出系统
                print('您已退出学生成绩管理系统！')
                ctrl = False
            elif option_int == 1:  # 录入学生成绩信息
                insert()
            elif option_int == 2:  # 查找学生成绩信息
                search()
            elif option_int == 3:  # 删除学生成绩信息
                delete()
            elif option_int == 4:  # 修改学生成绩信息
                modify()
            elif option_int == 5:  # 排序
                sort()
            elif option_int == 6:  # 统计学生总数
                total()
            elif option_int == 7:  # 显示所有学生信息
                show()
 
 
'''1 录入学生信息'''
 
 
def insert():
    stdentList = []        # 保存学生信息的列表
    mark = True  # 是否继续添加
    while mark:
        id = input("请输入ID（如 1001）：")
        if not id:  # ID为空，跳出循环
            break
        name = input("请输入名字：")
        if not name:  # 名字为空，跳出循环
            break
        try:
            english = int(input("请输入英语成绩："))
            python = int(input("请输入Python成绩："))
            c = int(input("请输入C语言成绩："))
        except:
            print("输入无效，不是整型数值．．．．重新录入信息")
            continue
        stdent = {"id": id, "name": name, "english": english, "python": python, "c": c}  # 将输入的学生信息保存到字典
        stdentList.append(stdent)  # 将学生字典添加到列表中
        inputMark = input("是否继续添加？（y/n）:")
        if inputMark == "y":  # 继续添加
            mark = True
        else:  # 不继续添加
            mark = False
    save(stdentList)  # 将学生信息保存到文件
    print("学生信息录入完毕！！！")
 
 
# 将学生信息保存到文件
def save(student):
    try:
        students_txt = open(filename, "a")  # 以追加模式打开
    except Exception as e:
        students_txt = open(filename, "w")  # 文件不存在，创建文件并打开
    for info in student:
        students_txt.write(str(info) + "\n")  # 按行存储，添加换行符
    students_txt.close()  # 关闭文件
 
 
'''2 查找学生成绩信息'''
 
 
def search():
    mark = True
    student_query = []  # 保存查询结果的学生列表
    while mark:
        id = ""
        name = ""
        if os.path.exists(filename):  # 判断文件是否存在
            mode = input("按ID查输入1；按姓名查输入2：")
            if mode == "1":
                id = input("请输入学生ID：")
            elif mode == "2":
                name = input("请输入学生姓名：")
            else:
                print("您的输入有误，请重新输入！")
                search()  # 重新查询
            with open(filename, 'r') as file:  # 打开文件
                student = file.readlines()  # 读取全部内容
                for list in student:
                    d = dict(eval(list))  # 字符串转字典
                    if id is not "":  # 判断是否按ID查
                        if d['id'] == id:
                            student_query.append(d)  # 将找到的学生信息保存到列表中
                    elif name is not "":  # 判断是否按姓名查
                        if d['name'] == name:
                            student_query.append(d)  # 将找到的学生信息保存到列表中
                show_student(student_query)  # 显示查询结果
                student_query.clear()  # 清空列表
                inputMark = input("是否继续查询？（y/n）:")
                if inputMark == "y":
                    mark = True
                else:
                    mark = False
        else:
            print("暂未保存数据信息...")
            return
 
 
'''3 删除学生成绩信息'''
 
 
def delete():
    mark = True  # 标记是否循环
    while mark:
        studentId = input("请输入要删除的学生ID：")
        if studentId is not "":  # 判断要删除的学生是否存在
            if os.path.exists(filename):  # 判断文件是否存在
                with open(filename, 'r') as rfile:  # 打开文件
                    student_old = rfile.readlines()  # 读取全部内容
            else:
                student_old = []
            ifdel = False  # 标记是否删除
            if student_old:  # 如果存在学生信息
                with open(filename, 'w') as wfile:  # 以写方式打开文件
                    d = {}  # 定义空字典
                    for list in student_old:
                        d = dict(eval(list))  # 字符串转字典
                        if d['id'] != studentId:
                            wfile.write(str(d) + "\n")  # 将一条学生信息写入文件
                        else:
                            ifdel = True  # 标记已经删除
                    if ifdel:
                        print("ID为 %s 的学生信息已经被删除..." % studentId)
                    else:
                        print("没有找到ID为 %s 的学生信息..." % studentId)
            else:  # 不存在学生信息
                print("无学生信息...")
                break  # 退出循环
            show()  # 显示全部学生信息
            inputMark = input("是否继续删除？（y/n）:")
            if inputMark == "y":
                mark = True  # 继续删除
            else:
                mark = False  # 退出删除学生信息功能
 
 
'''4 修改学生成绩信息'''
 
 
def modify():
    show()  # 显示全部学生信息
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as rfile:  # 打开文件
            student_old = rfile.readlines()  # 读取全部内容
    else:
        return
    studentid = input("请输入要修改的学生ID：")
    with open(filename, "w") as wfile:  # 以写模式打开文件
        for student in student_old:
            d = dict(eval(student))  # 字符串转字典
            if d["id"] == studentid:  # 是否为要修改的学生
                print("找到了这名学生，可以修改他的信息！")
                while True:  # 输入要修改的信息
                    try:
                        d["name"] = input("请输入姓名：")
                        d["english"] = int(input("请输入英语成绩："))
                        d["python"] = int(input("请输入Python成绩："))
                        d["c"] = int(input("请输入C语言成绩："))
                    except:
                        print("您的输入有误，请重新输入。")
                    else:
                        break  # 跳出循环
                student = str(d)  # 将字典转换为字符串
                wfile.write(student + "\n")   # 将修改的信息写入到文件
                print("修改成功！")
            else:
                wfile.write(student)  # 将未修改的信息写入到文件
    mark = input("是否继续修改其他学生信息？（y/n）：")
    if mark == "y":
        modify()  # 重新执行修改操作
 
 
'''5 排序'''
 
 
def sort():
    show()  # 显示全部学生信息
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as file:  # 打开文件
            student_old = file.readlines()  # 读取全部内容
            student_new = []
        for list in student_old:
            d = dict(eval(list))  # 字符串转字典
            student_new.append(d)  # 将转换后的字典添加到列表中
    else:
        return
    ascORdesc = input("请选择（0升序；1降序）：")
    if ascORdesc == "0":  # 按升序排序
        ascORdescBool = False           # 标记变量，为False表示升序排序
    elif ascORdesc == "1":  # 按降序排序
        ascORdescBool = True          # 标记变量，为True表示降序排序
    else:
        print("您的输入有误，请重新输入！")
        sort()  
    mode = input("请选择排序方式（1按英语成绩排序；2按Python成绩排序；3按C语言成绩排序；0按总成绩排序）：")
    if mode == "1":  # 按英语成绩排序
        student_new.sort(key=lambda x: x["english"], reverse=ascORdescBool)
    elif mode == "2":  # 按Python成绩排序
        student_new.sort(key=lambda x: x["python"], reverse=ascORdescBool)
    elif mode == "3":  # 按C语言成绩排序
        student_new.sort(key=lambda x: x["c"], reverse=ascORdescBool)
    elif mode == "0":  # 按总成绩排序
        student_new.sort(key=lambda x: x["english"] + x["python"] + x["c"], reverse=ascORdescBool)
    else:
        print("您的输入有误，请重新输入！")
        sort()
    show_student(student_new)  # 显示排序结果
 
 
''' 6 统计学生总数'''
 
 
def total():
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as rfile:  # 打开文件
            student_old = rfile.readlines()  # 读取全部内容
            if student_old:
                print("一共有 %d 名学生！" % len(student_old))
            else:
                print("还没有录入学生信息！")
    else:
        print("暂未保存数据信息...")
 
 
''' 7 显示所有学生信息 '''
 
 
def show():
    student_new = []
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as rfile:  # 打开文件
            student_old = rfile.readlines()  # 读取全部内容
        for list in student_old:
            student_new.append(eval(list))  # 将找到的学生信息保存到列表中
        if student_new:
            show_student(student_new)
    else:
        print("暂未保存数据信息...")
 
 
# 将保存在列表中的学生信息显示出来
def show_student(studentList):
    if not studentList:
        print("(o@.@o) 无数据信息 (o@.@o) \n")
        return
    format_title = "{:^6}{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^10}"
    print(format_title.format("ID", "名字", "英语成绩", "Python成绩", "C语言成绩", "总成绩"))
    format_data = "{:^6}{:^12}\t{:^12}\t{:^12}\t{:^12}\t{:^12}"
    for info in studentList:
        print(format_data.format(info.get("id"), info.get("name"), str(info.get("english")), str(info.get("python")),
                                 str(info.get("c")),
                                 str(info.get("english") + info.get("python") + info.get("c")).center(12)))
 
 
if __name__ == "__main__":
    main()

这段代码是一个使用Python的asyncio和aiohttp库来下载m3u8格式的视频文件的示例。m3u8是一种常用的视频流媒体播放列表格式，它将视频分割为一系列的小文件（.ts文件），通过播放列表进行调度播放。下面是代码的主要流程：

1. 导入所需的模块和库。
2. 设置下载相关的路径、URL和headers。
3. 使用aiohttp异步获取第一次URL，该URL是一个m3u8文件的地址。
4. 使用aiohttp异步获取m3u8文件的URL，该URL是m3u8播放列表文件的地址。
5. 使用aiohttp异步获取ts文件的URL，并将ts文件的完整URL存储到列表中。
6. 并发地下载所有的ts文件，存储在指定的目录中。
7. 使用ffmpeg命令将下载的ts文件合并成一个完整的视频文件。

请注意，要运行这段代码，需要满足以下条件：

1. 安装所需的Python库：aiohttp、ffmpeg-python。
2. 确保已安装并配置好了ffmpeg，以便能够执行合并操作。
3. 根据需要，可以修改路径、URL、文件名等设置。
4. 请注意合并操作可能需要一些时间，具体取决于视频文件的大小和下载速度。

此外，要注意这段代码在下载过程中禁用了证书验证，这在正式环境中是不安全的做法。在实际使用中，应该考虑启用证书验证以确保安全性。

import os.path
import urllib.parse
import asyncio
import aiohttp
import re

# 禁用证书验证警告
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

path = 'ts'
# 目标URL
url = 'https://www.99meijutt.com/play/102788-1-0.html'

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

ts_url_list = []

# 获取第一次url
async def get_url(url):
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get(url, verify_ssl=False) as response:
            data = await response.text()
    url_m3u8 = re.search('now="(.*?)"', data).group(1)
    return url_m3u8

# 获取m3u8文件的URL
async def get_m3u8url(url_m3u8):
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get(url_m3u8, verify_ssl=False) as response:
            data = await response.text()
    # 使用最后一行的URL拼接完整的m3u8文件URL
    url2 = urllib.parse.urljoin(url_m3u8, data.split()[-1])
    return url2

# 获取ts文件的URL并下载
async def get_tsurl(url2, base_url):
    i = 0
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get(url2, verify_ssl=False) as response:
            data = await response.content.read()

    with open('u8m3_url.m3u8', 'wb') as f:
        f.write(data)

    with open('u8m3_url.m3u8', 'r') as f:
        get_tsurll = f.readlines()
    aa = open(os.path.join(path, 'do_m3u8.m3u8'), 'w')
    for ts_url in get_tsurll:
        if ts_url.startswith("#"):
            aa.write(ts_url)
            continue
        else:
            aa.write(str(i) + f'.{path}\n')
            # 拼接完整的ts文件URL
            full_ts_url = urllib.parse.urljoin(base_url, ts_url.strip())
            ts_url_list.append(full_ts_url)
        i += 1

# 下载ts文件
async def download(full_ts_url, i):
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get(full_ts_url, verify_ssl=False) as response:
            data = await response.content.read()

    if not os.path.exists(path):
        os.mkdir(path)

    with open(os.path.join(path, str(i) + '.ts'), 'wb') as f:
        f.write(data)
        print('下载完成')

def merge(filename='output'):
    '''
    进行ts文件合并 解决视频音频不同步的问题 建议使用这种
    :param filePath:
    :return:
    '''
    print('开始')

    c = os.chdir(path)
    print(c)
    cmd = f'ffmpeg -i do_m3u8.m3u8 -c copy {filename}.mp4'
    os.system(cmd)
    print('结束')

async def main():
    # 获取第一次的URL
    first_url = await get_url(url)
    print('第一次的URL：', first_url)

    # 获取m3u8文件的URL
    m3u8_url = await get_m3u8url(first_url)
    print('m3u8文件的URL：', m3u8_url)

    # 获取ts文件的URL并下载
    await get_tsurl(m3u8_url, first_url)

    # 并发下载TS文件
    tasks = []
    for i, ts_url in enumerate(ts_url_list):
        tasks.append(download(ts_url, i))

    await asyncio.gather(*tasks)

    merge()

if __name__ == '__main__':
    asyncio.run(main())

'''
学籍照片自动裁剪工具：
1.自动将整个文件夹的照片用人脸识别的方式，以人脸为中心向周边延伸2倍来裁剪头像。
2.生成的图片大小为260*320像素，符合中小学学籍照片规格。一般容量都是20-30KB左右。
3.经测试，人脸识别还是很准确的，放个狗头上去就识别不了
# 在终端运行这个命令 python -m pip install dlib-19.22.99-cp38-cp38-win_amd64.whl
by xinixu 2023.7.21
'''
import cv2
import dlib
import os
 
def detect_face_and_half_body(input_image_path, output_image_path, target_size=(260, 320), extend_ratio=1.0):
    # 使用OpenCV加载图像
    image = cv2.imread(input_image_path)
 
    # 将图像转换为灰度图像，以加快人脸检测速度
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
    # 从Dlib加载人脸检测器模型
    face_detector = dlib.get_frontal_face_detector()
 
    # 在图像中检测人脸
    faces = face_detector(gray_image)
 
    if len(faces) > 0:
        # 假设图像中只有一个人脸（你可以修改代码来处理多个人脸）
        face = faces[0]
 
        # 获取人脸的边界框坐标
        x, y, w, h = face.left(), face.top(), face.width(), face.height()
 
        # 计算人脸的中心点
        center_x = x + w // 2
        center_y = y + h // 2
 
        # 计算半身图像的裁剪区域的坐标
        crop_width = int(w * (1 + extend_ratio))
        crop_height = int(h * (1 + extend_ratio))
        crop_x1 = max(0, center_x - crop_width // 2)
        crop_y1 = max(0, center_y - crop_height // 2)
        crop_x2 = min(center_x + crop_width // 2, image.shape[1])
        crop_y2 = min(center_y + crop_height // 2, image.shape[0])
 
        # 裁剪图像以获取半身图像
        half_body_image = image[crop_y1:crop_y2, crop_x1:crop_x2]
 
        # 将半身图像调整到目标尺寸
        resized_image = cv2.resize(half_body_image, target_size, interpolation=cv2.INTER_AREA)
 
        # 保存调整后的图像
        cv2.imwrite(output_image_path, resized_image)
 
        print(f"检测到人脸，半身图像已保存：{output_image_path}")
    else:
        print(f"未在图像中检测到人脸：{input_image_path}")
 
def batch_detect_face_and_half_body(input_folder, output_folder, target_size=(260, 320), extend_ratio=1.0):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
 
    for filename in os.listdir(input_folder):
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
            input_image_path = os.path.join(input_folder, filename)
            output_image_path = os.path.join(output_folder, filename)
            detect_face_and_half_body(input_image_path, output_image_path, target_size, extend_ratio)
 
if __name__ == "__main__":
    input_folder = "G:\\201901"  # 替换为你的输入文件夹路径
    output_folder = "G:\\20190101"  # 替换为你的输出文件夹路径
    target_size = (260, 320)
    extend_ratio = 2.0  # 增大extend_ratio以获得更大范围的半身图像
 
    batch_detect_face_and_half_body(input_folder, output_folder, target_size, extend_ratio)

程序运行后有几个选项可以选择，然后根据提示输入文本即可获得加/解密结果。
源码仅供参考，由于安全性以及加密算法的复杂度不够，请勿用于专业用途。

from base64 import b64decode,b64encode
import hashlib
from Crypto.Cipher import AES
 
ver = 2.0
numset = 0
 
def code_base64(code, state=1):
    if state == 1:
        try:
            en = b64encode(code.encode('utf-8')).decode("utf-8")
            return en
        except:
            return False
    elif state == 2:
        try:
            de = b64decode(code.encode("utf-8")).decode("utf-8")
            return de
        except:
            return False
    else:
        return None
 
key = {
    "1":"g", "2":"8", "3":"m", "4":"o", "5":"P", "6":"a", "7":"s", "8":"5", "9":"d", "0":"i",
    "a":"f", "b":"h", "c":"b", "d":"k", "e":"j", "f":"c", "g":"e", "h":"n", "i":"1", "j":"2",
    "k":"3", "l":"4", "m":"0", "n":"B", "o":"E", "p":"O", "q":"Q", "r":"R", "s":"U", "t":"Z",
    "u":"T", "v":"M", "w":"q", "x":"X", "y":"z", "z":"A", "A":"p", "B":"r", "C":"l", "D":"u",
    "E":"v", "F":"w", "G":"I", "H":"J", "I":"C", "J":"x", "K":"y", "L":"N", "M":"t", "N":"9",
    "O":"6", "P":"7", "Q":"L", "R":"H", "S":"G", "T":"D", "U":"S", "V":"F", "W":"K", "X":"W",
    "Y":"V", "Z":"Y"
}
 
key_new = {
    "g":"1", "8":"2", "m":"3", "o":"4", "P":"5", "a":"6", "s":"7", "5":"8", "d":"9", "i":"0",
    "f":"a", "h":"b", "b":"c", "k":"d", "j":"e", "c":"f", "e":"g", "n":"h", "1":"i", "2":"j",
    "3":"k", "4":"l", "0":"m", "B":"n", "E":"o", "O":"p", "Q":"q", "R":"r", "U":"s", "Z":"t",
    "T":"u", "M":"v", "q":"w", "X":"x", "z":"y", "A":"z", "p":"A", "r":"B", "l":"C", "u":"D",
    "v":"E", "w":"F", "I":"G", "J":"H", "C":"I", "x":"J", "y":"K", "N":"L", "t":"M", "9":"N",
    "6":"O", "7":"P", "L":"Q", "H":"R", "G":"S", "D":"T", "S":"U", "F":"V", "K":"W", "W":"X",
    "V":"Y", "Y":"Z"
}
 
def set_numset():
    global numset
    numset = int(input("请设置加密字典(默认0，可设置0到无限): "))
    print("加密字典设置成功！")
 
def encrypt():
    global numset
    key = input("请输入加密密钥：") # 新增加密密钥输入
    key = hashlib.sha256(key.encode()).digest() # 对密钥进行哈希处理，得到32字节的密钥
    code = input("请输入要加密的内容: ")
    code = code_base64(code)
    code2 = ""
    for i in code:
        try:
            code2 += key[i + str(numset)]
        except:
            code2 += i
    cipher = AES.new(key, AES.MODE_EAX) # 使用AES算法进行加密，选择EAX模式，可以避免填充问题
    ciphertext, tag = cipher.encrypt_and_digest(code2.encode()) # 加密后得到密文和验证标签
    print(b64encode(cipher.nonce + tag + ciphertext).decode(), "\n") # 将随机数、标签和密文拼接后进行base64编码输出
 
def decrypt():
    global numset
    key = input("请输入解密密钥：") # 新增解密密钥输入
    key = hashlib.sha256(key.encode()).digest() # 对密钥进行哈希处理，得到32字节的密钥
    code = input("请输入要解密的内容: ")
    code = b64decode(code) # 对输入的内容进行base64解码
    nonce = code[:16] # 取出随机数部分
    tag = code[16:32] # 取出验证标签部分
    ciphertext = code[32:] # 取出密文部分
    cipher = AES.new(key, AES.MODE_EAX, nonce=nonce) # 使用AES算法进行解密，选择EAX模式，传入随机数参数
    try:
        data = cipher.decrypt_and_verify(ciphertext, tag) # 解密并验证标签，如果不匹配会抛出异常
        code2 = ""
        for i in data.decode():
            try:
                code2 += key_new[i - numset]
            except:
                code2 += i
        code2 = code_base64(code2, 2)
        print(code2, "\n")
    except:
        print("解密失败，可能是因为密钥错误或者数据被篡改\n")
 
def main():
    while True:
        print("1.加密")
        print("2.解密")
        print("3.加密字典设置")
        print("4.关于")
        print("5.退出")
        try:
            state = int(input("请选择："))
        except:
            state = 4
        if state == 1:
            encrypt()
        elif state == 2:
            decrypt()
        elif state == 3:
            set_numset()
        elif state == 4:
            print("Tao Yuanhang Encryption and Decryption(TED) version ", ver)
            print("基于base64编码以及一些简易加密算法，程序本身仅供学习使用。")
        elif state == 5:
            break
        else:
            print("错误！")
 
main()

目前已经支持 2个汉字,3个汉字,4个汉字的拼音.

pip install flet
# 声母列表
initial_consonant_list = ['b', 'p', 'm', 'f', 'd', 't', 'n', 'l', 'g', 'k', 'h', 'j', 'q', 'x', 'zh', 'ch', 'sh', 'r',
                          'z', 'c', 's', 'y', 'w']
# 韵母列表
list_of_vowels = ['a', 'o', 'e', 'i', 'u', 'ü', 'ai', 'ei', 'ui', 'ao', 'ou', 'iu', 'ie', 'üe', 'er', 'an', 'en', 'in',
                  'un', 'ün', 'ang', 'eng', 'ing', 'ong']
 
 
class Chinese2PinYin(UserControl):
 
    # 构造方法
    def __init__(self, page: Page):
        super().__init__()
        self.page = page
        self.content = TextField(label='词语之间用空格分割!', multiline=True)
        # 模板路径
        self.template_path = None
        # 生成word路径
        self.word_doc_path = None
        # 创建一个DataTable
        self.table = DataTable(
            border=flet.border.all(0.8, "black"),
            bgcolor=flet.colors.GREY_50,
            border_radius=10,
            vertical_lines=flet.border.BorderSide(1, "black"),
            horizontal_lines=flet.border.BorderSide(1, "black"),
            visible=False,
            columns=[
                DataColumn(Text("词语")),
                DataColumn(Text("本地")),
                DataColumn(Text("百度")),
            ]
        )
        # 保存拼音不同的记录
        self.table_rows = []
        # 选择模板
        self.file_template = flet.FilePicker(on_result=self.pick_file_result)
        # 注音按钮
        self.zhuyin_btn = ElevatedButton('注音', disabled=True, icon=flet.icons.SAVE, on_click=self.generate_pinyin)
 
    def build(self):
        self.page.overlay.append(self.file_template)
        return Column(controls=[
            Row(
                controls=[
                    Text('声母: ', size=20),
                    Text('\t'.join(initial_consonant_list), size=18)
                ]
            ),
            Column(
                controls=[
                    Text('韵母(24个): ', size=20),
                    Row(
                        controls=[
                            Text('单韵母(6个): ', size=18),
                            Text('\t'.join(list_of_vowels[0:6]), size=18)
                        ]
                    ),
                    Row(
                        controls=[
                            Text('复韵母(8个): ', size=18),
                            Text('\t'.join(list_of_vowels[6:14]), size=18)
                        ]
                    ),
                    Row(
                        controls=[
                            Text('特殊元音韵母(1个): ', size=18),
                            Text(list_of_vowels[14], size=18)
                        ]
                    ),
                    Row(
                        controls=[
                            Text('前鼻韵母(5个): ', size=18),
                            Text('\t'.join(list_of_vowels[15:20]), size=18)
                        ]
                    ),
                    Row(
                        controls=[
                            Text('后鼻韵母(4个): ', size=18),
                            Text('\t'.join(list_of_vowels[20:]), size=18)
                        ]
                    ),
                ]
            ),
            # 分割器
            flet.Divider(height=3, color=flet.colors.BROWN_50),
            Text(value='请输入要注音的汉字: ', size=20),
            self.content,
            Row(
                controls=[
                    ElevatedButton('选择模板...', icon=flet.icons.UPLOAD_FILE, on_click=self.select_template),
                    self.zhuyin_btn
                ],
                alignment=flet.MainAxisAlignment.END
            ),
            self.table,
        ])
 
    def pick_file_result(self, e: flet.FilePickerResultEvent):
        if e.files:
            for file in e.files:
                self.template_path = file.path
                print(f'名称:{file.name}, 大小: {file.size}')
        self.zhuyin_btn.disabled = False
        self.update()
 
    def select_template(self, e):
        self.file_template.pick_files(dialog_title='选择拼音模板', initial_directory='.', allowed_extensions=['doc', 'docx'])
 
    def generate_pinyin(self, e):
        """
        点击"拼音"按钮事件
        :param e:
        :return:
        """
        txt = self.content.value
        # 输出所有的词语
        print(txt)
        self.word_2_pinyin(txt)
        # 表格赋值
        self.table.visible = True
        self.table.rows.extend(self.table_rows)
        self.update()
 
        def close_dlg(e):
            dialog.open = False
            os.startfile(pathlib.Path.home())  # windows平台打开指定的目录
            self.page.update()
 
        # 弹框提示word生成路径
        dialog = AlertDialog(
            title=Text('生成文档路径'),
            actions=[
                TextButton("确定", on_click=close_dlg)
            ],
            actions_alignment=flet.MainAxisAlignment.END,
        )
        self.page.dialog = dialog
        dialog.content = Text(self.word_doc_path)
        dialog.open = True
        self.page.update()
 
    def word_2_pinyin(self, ciyu):
        """
        词组或汉字转拼音
        """
        # 读取模板
        doc = DocxTemplate(self.template_path)
        # 保存汉字和拼音列表结果
        py_hz = []
        all_words = [item for item in ciyu.strip().replace('\n', ' ').split(" ") if item]  # 去掉换行符,并用空格分割
        line_word_num = 7  # 每行词组个数
        for j in range(1, math.ceil(len(all_words) / line_word_num) + 1):
            word_5 = all_words[line_word_num * (j - 1):line_word_num * j]
            row_1 = {}
            for i in range(len(word_5)):
                py = lazy_pinyin(word_5[i], style='Style.TONE')
                baidu_pinyin = chinese_2_pinyin(word_5[i], 'BAIDU', True)
                if baidu_pinyin and baidu_pinyin == ' '.join(py):
                    pass
                else:
                    self.table_rows.append(DataRow(
                        cells=[
                            DataCell(Text(word_5[i])),
                            DataCell(Text(' '.join(py), selectable=True)),
                            DataCell(Text(baidu_pinyin, selectable=True)),
                        ]))
                if pinyin_start_valid(py[0]):
                    row_1[f'p{i + 1}1'] = py[0][0:2]
                    row_1[f'p{i + 1}2'] = py[0][2:]
                else:
                    row_1[f'p{i + 1}1'] = py[0][0]
                    row_1[f'p{i + 1}2'] = py[0][1:]
 
                if pinyin_start_valid(py[1]):
                    row_1[f'p{i + 1}3'] = py[1][0:2]
                    row_1[f'p{i + 1}4'] = py[1][2:]
                else:
                    row_1[f'p{i + 1}3'] = py[1][0]
                    row_1[f'p{i + 1}4'] = py[1][1:]
                max_len = max([len(i) for i in py])
                if max_len > 3:
                    row_1[f'h{i + 1}'] = '  '.join(list(word_5[i]))
                elif max_len > 2:
                    row_1[f'h{i + 1}'] = ' '.join(list(word_5[i]))
            py_hz.append(row_1)
        # 需要传入的字典， 需要在word对应的位置输入 {{ first_py }}
        context = {"items": py_hz}
        doc.render(context)  # 渲染到模板中
        # 生成文档
        self.word_doc_path = f"{pathlib.Path.home()}{os.sep}拼音在汉字上面(表格).docx"
        doc.save(self.word_doc_path)
 
 
def pinyin_start_valid(pinyin):
    """判断拼音是否以zh,ch,sh开头"""
    return pinyin.startswith('zh') or pinyin.startswith('ch') or pinyin.startswith('sh')
 
 
def main(page: Page):
    # 标题
    page.title = '生成汉字拼音工具v1.0'
    page.window_width = 800
    page.window_height = 700
    # 居中
    page.window_center()
 
    app = Chinese2PinYin(page)
 
    page.add(app)
 
 
if __name__ == '__main__':
    flet.app(target=main, assets_dir='assets')

这段代码使用PyQt5库创建了一个圆角窗口应用，具有以下功能：

1. 窗口圆角效果：窗口的外边框为圆角，可以自定义圆角的半径。
2. 系统托盘图标：应用可以最小化到系统托盘，并在托盘中显示图标。
3. 托盘右键菜单：点击托盘图标后可以弹出右键菜单，包括退出应用选项。
4. 拖拽移动窗口：按住鼠标左键拖动窗口可以改变窗口的位置。
5. 窗口按钮：在窗口左上角有三个圆形按钮，分别是关闭、最小化和最大化（实际为灰色，无功能）。
6. 文本编辑框：窗口中间部分为一个文本编辑框，可以输入文本内容并保存到文件。
7. 字体大小调整：可以通过Ctrl + 鼠标滚轮来调整文本编辑框中的字体大小。
8. 窗口最小化到托盘：关闭窗口时会最小化到托盘，通过托盘图标可以恢复窗口显示。

代码使用QMainWindow作为主窗口，自定义了窗口外观，圆角效果使用了paintEvent方法绘制半透明背景以及关闭、最小化、最大化按钮。鼠标事件处理方法实现了窗口的移动、拖动调整大小、以及关闭、最小化功能。通过QSystemTrayIcon和系统托盘交互，实现窗口最小化到托盘，以及在托盘中显示菜单和图标。此外，通过调用setFont方法来实现文本编辑框中字体大小的调整。

在运行之前，确保已经安装了PyQt5库，并准备了noteIcon.png图标文件。需要注意，系统托盘功能在不同操作系统中可能有不同的表现，可能会受到系统设置的影响。

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu, QAction, QSystemTrayIcon, QMessageBox, QTextEdit
from PyQt5.QtCore import Qt, QPoint, QRect, QSize
from PyQt5.QtGui import QPainter, QColor, QBrush, QPen, QIcon, QFont, QCursor
 
class RoundedWindow(QMainWindow):
    def __init__(self, radius):
        super().__init__()
        self.setWindowFlags(Qt.FramelessWindowHint)
        self.setAttribute(Qt.WA_TranslucentBackground)
        self.setGeometry(700, 400, 400, 300)
        self.radius = radius
        self.draggable = False
        self.drag_position = QPoint()
        self.default_font_size = 13
        self.current_font_size = self.default_font_size
        self.resizing = False
 
        # 创建系统托盘图标
        self.tray_icon = QSystemTrayIcon(self)
        self.tray_icon.setIcon(QIcon("noteIcon.png"))
        self.tray_icon.activated.connect(self.handleTrayIconActivated)
 
        # 创建鼠标右键菜单
        self.tray_menu = QMenu(self)
        exit_action = QAction("退出", self)
        exit_action.triggered.connect(QApplication.instance().quit)
        self.tray_menu.addAction(exit_action)
        self.tray_icon.setContextMenu(self.tray_menu)
 
        # 创建文本编辑框
        self.text_edit = QTextEdit(self)
        self.text_edit.setGeometry(10, 40, self.width() - 20, self.height() - 50)
        self.text_edit.setStyleSheet("background-color: transparent; border: none; color: white;")
        self.text_edit.setFont(QFont("Arial", self.current_font_size))
        self.text_edit.textChanged.connect(self.saveTextToFile)
 
    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        painter.setBrush(QColor(0, 0, 0, 150))  # 设置半透明背景颜色
        painter.drawRoundedRect(self.rect(), self.radius, self.radius)
 
        # 绘制红色关闭按钮
        close_button = QRect(10, 10, 20, 20)
        painter.setBrush(QColor(255, 0, 0))
        painter.setPen(Qt.NoPen)
        painter.drawEllipse(close_button)
 
        # 绘制黄色最小化按钮
        minimize_button = QRect(40, 10, 20, 20)
        painter.setBrush(QColor(255, 255, 0))
        painter.setPen(Qt.NoPen)
        painter.drawEllipse(minimize_button)
 
        # 绘制灰色最大化按钮
        maximize_button = QRect(70, 10, 20, 20)
        painter.setBrush(QColor(128, 128, 128))
        painter.setPen(Qt.NoPen)
        painter.drawEllipse(maximize_button)
 
    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.draggable = True
            self.drag_position = event.globalPos() - self.frameGeometry().topLeft()
            event.accept()
 
            # 判断点击的按钮
            pos = event.pos()
            if QRect(10, 10, 20, 20).contains(pos):
                self.close()  # 关闭当前窗口
            elif QRect(40, 10, 20, 20).contains(pos):
                self.hide()  # 最小化当前窗口
 
    def mouseMoveEvent(self, event):
        if event.buttons() == Qt.LeftButton and self.draggable:
            self.move(event.globalPos() - self.drag_position)
            event.accept()
 
        # 检查是否在窗口右下角，设置鼠标形状
        if self.isInBottomRightCorner(event.pos()):
            self.setCursor(Qt.SizeFDiagCursor)
        else:
            self.setCursor(Qt.ArrowCursor)
 
        # 检查是否正在调整窗口大小
        if self.resizing:
            self.resizeWindow(event.globalPos())
 
    def mouseReleaseEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.draggable = False
            self.resizing = False
            event.accept()
 
    def handleTrayIconActivated(self, reason):
        if reason == QSystemTrayIcon.Trigger:
            self.showNormal()  # 点击托盘图标恢复窗口显示
 
    def closeEvent(self, event):
        self.hide()  # 窗口关闭时隐藏而不是退出应用程序
        self.tray_icon.show()  # 显示系统托盘图标
        event.ignore()  # 忽略窗口关闭事件
 
    def saveTextToFile(self):
        text = self.text_edit.toPlainText()
        with open("bianqian.txt", "w") as file:
            file.write(text)
 
    def isInBottomRightCorner(self, pos):
        window_rect = self.rect()
        corner_rect = QRect(window_rect.bottomRight() - QPoint(20, 20), QSize(20, 20))
        return corner_rect.contains(pos)
 
    def resizeWindow(self, pos):
        new_size = QSize(pos.x() - self.geometry().left(), pos.y() - self.geometry().top())
        self.resize(new_size)
 
    def wheelEvent(self, event):
        if event.modifiers() == Qt.ControlModifier:
            delta = event.angleDelta().y()
            if delta > 0:
                self.increaseFontSize()
            else:
                self.decreaseFontSize()
 
    def increaseFontSize(self):
        self.current_font_size += 1
        self.text_edit.setFont(QFont("Arial", self.current_font_size))
 
    def decreaseFontSize(self):
        if self.current_font_size > 1:
            self.current_font_size -= 1
            self.text_edit.setFont(QFont("Arial", self.current_font_size))
 
if __name__ == '__main__':
    app = QApplication(sys.argv)
    radius = 15  # 修改圆角的值
    window = RoundedWindow(radius)
    window.show()
 
    # 调试：检查系统托盘是否可用
    if not QSystemTrayIcon.isSystemTrayAvailable():
        QMessageBox.critical(None, "错误", "系统托盘不可用！")
        sys.exit(1)
 
    # 调试：检查图标是否加载成功
    if not window.tray_icon.isSystemTrayAvailable():
        QMessageBox.critical(None, "错误", "无法加载系统托盘图标！")
        sys.exit(1)
 
    window.tray_icon.show()
    sys.exit(app.exec_())

1.加入进程池

import os.path
import random
import time
import requests
from lxml import etree
import threading
from multiprocessing import Pool
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36'
}
url = 'https://pic.netbian.com'

def huoqu(urll):

    print('我已经运行了')

    # 发送HTTP请求，获取页面内容
    respones = requests.get(urll, headers=headers)
    mg = respones.content.decode("gbk")
    tree = etree.HTML(mg)
    # 使用XPath选择器提取图片URL和相关信息
    img_url = tree.xpath('//ul[@class="clearfix"]//li')

    for a in img_url:
        c = a.xpath('./a//img/@alt')[0]
        img_mg = a.xpath('./a//img/@src')
        img_mgg = requests.get('https://pic.netbian.com' + ''.join(img_mg))
        if not os.path.exists('彼岸图网'):
            os.mkdir("彼岸图网")
        with open(f'彼岸图网/{c}.jpg', 'wb') as f:
            f.write(img_mgg.content)
            print(f'彼岸图网/{c}.jpg，保存成功')

def zongpage(url):
    # 发送HTTP请求，获取页面内容
    respones = requests.get(url, headers=headers)
    mg = respones.content.decode("gbk")
    tree = etree.HTML(mg)
    # 使用XPath选择器提取总页数
    page = tree.xpath('//div[@class="page"]/a/text()')
    zongpage = page[-2]
    print('总共：' + zongpage + '页')
    return zongpage

zongpagee = zongpage(url)

if __name__ == '__main__':
    threads = []
#Pool(5)可以调整进程数量  不填则按照CPU最大核心数来并发不填会有死机风险，最好不要超过10
    pool = Pool(5)
    for a in range(1, int(zongpagee)):
        if a == 1:
            # 第一页直接调用huoqu函数
            huoqu(url)
        else:
            uu = f'{url}/index_{a}.html'
            print(uu)
            threads.append(uu)

    for i in range(1, int(zongpagee)):
        # 创建线程并启动
        pool.map(huoqu,threads)
        pool.close()

        # 随机延迟一段时间
        time.sleep(random.randint(2, 5))

    for t in threads:
        # 等待所有线程完成
        pool.join()
    print("完事")

这段代码使用了Tkinter库创建了一个简单的图形界面，用于执行SVN操作。主要功能包括：

1. 更新SVN：执行TortoiseProc.exe命令的更新操作。
2. 清理SVN：执行TortoiseProc.exe命令的清理操作。
3. 查看日志：执行TortoiseProc.exe命令的查看日志操作。
4. 还原SVN：执行TortoiseProc.exe命令的还原操作。
5. 重新定位：执行TortoiseProc.exe命令的重新定位操作。
6. 帮助：执行TortoiseProc.exe命令的帮助操作。

代码使用了多线程来处理按钮点击事件，避免界面卡死。界面中的输入框用于输入SVN地址，按钮点击后会执行相应的操作，并在底部的文本框中显示操作结果。

需要注意的是，这段代码需要依赖TortoiseProc.exe，这是TortoiseSVN的可执行文件，它需要在系统中正确配置才能正常运行。代码中使用的是Windows系统的命令行操作。在运行之前，确保TortoiseProc.exe在系统的环境变量中或者与脚本同一目录下。

此外，代码中使用了threading库来创建多线程，确保界面在操作时不会卡死。需要注意多线程可能带来的线程安全问题。

import os
import tkinter as tk
import threading
import time
 
def gengxi1():
    t.delete(1.0, tk.END)
    with open('C:\gjg\svn.txt', 'w') as f:
        f.write(txt.get())
    b = txt.get()
    print(b)
    try:
        c=os.system("TortoiseProc.exe /command:update /path:"+'"'+b+'"'+"/closeonend:1")
    except:
        print('更新失败')
        t.insert('end','更新失败')
    else:
        if c==0:
            print('更新成功')
            t.insert('end', '更新成功')
            a=(time.strftime("%Y-%m-%d-%H:%M:%S", time.localtime()))
            t.insert('end',a)
        else:
            print('更新失败')
            t.insert('end', '更新失败')
def qingli():
    t.delete(1.0, tk.END)
    with open(r'C:\gjg\svn.txt', 'w') as f:
        f.write(txt.get())
    b = txt.get()
    print(b)
    try:
        c = os.system("TortoiseProc.exe /command:cleanup /path:" + '"' + b + '"' + "/closeonend:1")
    except:
        t.insert('end', '清理失败')
    else:
        if c == 0:
            t.insert('end', '清理成功')
        else:
            t.insert('end', '清理失败')
def rizhi():
    t.delete(1.0, tk.END)
    with open(r'C:\gjg\svn.txt', 'w') as f:
        f.write(txt.get())
    b = txt.get()
    os.system("TortoiseProc.exe /command:log /path:" + '"' + b + '"' + "/closeonend:1")
def huanyuan():
    t.delete(1.0, tk.END)
    with open(r'C:\gjg\svn.txt', 'w') as f:
        f.write(txt.get())
    b = txt.get()
    print(b)
    os.system("TortoiseProc.exe /command:revert /path:" + '"' + b + '"' + "/closeonend:1")
    a = (time.strftime("%Y-%m-%d-%H:%M:%S", time.localtime()))
    t.insert('end', a)
def dingwei():
    t.delete(1.0, tk.END)
    with open(r'C:\gjg\svn.txt', 'w') as f:
        f.write(txt.get())
    b = txt.get()
    print(b)
    os.system("TortoiseProc.exe /command:relocate /path:" + '"' + b + '"' + "/closeonend:1")
def bangzhu():
    t.delete(1.0, tk.END)
    with open(r'C:\gjg\svn.txt', 'w') as f:
        f.write(txt.get())
    b = txt.get()
    print(b)
    os.system("TortoiseProc.exe /command:help /path:" + '"' + b + '"' + "/closeonend:1")
 
def thread_it(func, *args):
    '''将函数打包进线程'''
    k = threading.Thread(target=func, args=args)
    k.setDaemon(True)
    k.start()
 
if __name__ == '__main__':
    window=tk.Tk()
    window.title('SVN')
    window.geometry("200x250")
    if not os.path.exists("C:/gjg"):
        os.mkdir("C:/gjg")
    try:
        with open('C:\gjg\svn.txt', "r") as f:
            e1=f.read()
            print(e1)
    except:
        e1='地址，多个地址用*分隔'
    t= tk.Text(window,width = '250', height=11,bg = 'LightBlue')
    t.pack(side = 'bottom')
    btn1 = tk.Button(window, text="更新svn", bg="orange", command=lambda: thread_it(gengxi1))
    btn1.place(x=1, y=40)
    btn2 = tk.Button(window, text="清理svn", bg="orange", command=qingli)
    btn2.place(x=60, y=40)
    btn3 = tk.Button(window, text="查看日志", bg="orange", command=lambda: thread_it(rizhi))
    btn3.place(x=120, y=40)
    btn4 = tk.Button(window, text="还原svn", bg="orange", command=lambda: thread_it(huanyuan))
    btn4.place(x=1, y=70)
    btn5 = tk.Button(window, text="重新定位", bg="orange", command=lambda: thread_it(dingwei))
    btn5.place(x=60, y=70)
    btn6 = tk.Button(window, text="帮助", bg="orange", command=lambda: thread_it(bangzhu))
    btn6.place(x=130, y=70)
    e1 = tk.StringVar(value=e1)
    txt = tk.Entry(window, width=30,textvariable = e1)
    txt.place(x =1,y=10)
 
 
    window.mainloop()

这段代码是一个Python脚本，它可以根据给定的原创力文库链接下载文档，并将文档的每一页合并为一个PDF文件。代码的主要功能包括：

1. 输入原创力文库链接。
2. 解析文档信息，包括标题、view_token、文件类型、页数等。
3. 根据接口获取每一页的图片链接。
4. 下载每一页的图片。
5. 将下载的图片合并为PDF文件。

这段代码主要使用了requests库来进行网络请求，img2pdf库来将图片合并为PDF文件，以及PIL库来处理图片。

需要注意的是，文档的下载可能受到接口限制，需要2秒钟的间隔，下载速度可能会受到影响。

此外，这段代码仅供学习和个人使用，使用它时请确保遵守相关网站的使用规定和法律法规，不要用于商业用途。

# !/usr/bin/python
# -*- coding: UTF-8 -*-
import re
import json
import os
import shutil
import sys
import time
import requests
import img2pdf
from PIL import Image
 
from alive_progress import alive_bar
from requests.exceptions import SSLError
 
png_headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36',
    'Referer': 'https://max.book118.com/',
}
 
 
def down_pngs(pageIndex):
    print(pngs[pageIndex])
    down_url = 'https://view-cache.book118.com' + pngs[pageIndex]
    print(down_url)
    res = requests.get(url=down_url)
    try:
        png = res.content
        with open(os.path.join(temp_dir, str(pageIndex) + '.jpeg'), 'wb') as f:
            f.write(png)
    except:
        return
 
 
logo = """                  __  __
      _ _        /_@)_@) \          /^^\ /^\ /^^\_ 
    _/oo \____/~''. . .  '~\       /'\''  ~ ''~~' -'\_ 
   / '.'. ~.~.~.       .'    ~ |     /'\~~..''''.'' ''  ~\_ 
  ('_'_'_'_'_'_'_'_  ' :   '     \_/' '.''  . '.   .''  '.  ~\_ 
  ~V~V~V~V  \   ~\  '' '~  '   '' ~   `   ~  ''   ~\_ 
    /\~/\~/\~/\~/|/  '   ''  _   ' ~ ''  '    ~  '' __  '  ..  \_ 
 <-- --- ---.---.--/'   ''   /'  '\_ '' ': ~ ;;''    ' /''; \ ;'''''' '' ~\ _ 
    \~ '. . : .:: ~. :.  /_'''_'' \_' :'''_ : _ ''/''_' '_ \:_ '''' #''..\/\/\/~/\~ ''~~~~~O
 ~~ \-~ `---~~~---- \(_)(_)(_)/ ~ ~~' ~\(_)(_)(_)\_~_~_~_~_~/&#732;¤1
 ---------------------------------------------------------------------------------------------by:bean0283
"""
print(logo)
 
while True:
    url = input('请输入原创力文库url:')
    url = url.split('?')[0]
    print('下载地址：', url)
    temp_dir = url.split('/')[-1]
 
    # 删除老的临时文件夹并新建临时文件夹
    if os.path.exists(temp_dir):
        shutil.rmtree(temp_dir)
    os.mkdir(temp_dir)
 
    print('开始下载 HTML...', end='')
 
    try:
        response = requests.get(url=url)
    except(SSLError):
        print("\n\033[31m不要使用代理软件-------\033[0m")
        print("\033[31m请关闭代理软件后重新运行程序\033[0m")
        print("\033[31m请关闭vpn软件后重新运行程序\033[0m")
        sys.exit(0)
 
    page = response.text
 
    print('成功. \n开始解析 HTML...', end='')
 
    title = re.search('title: (.*),', page).group(1).replace("'", "")
    view_token = re.search('view_token: (.*)\'', page).group(1).replace("'", "")
    filetype = re.search('format: (.*)\'', page).group(1).replace("'", "")
    senddate = re.search('senddate: (.*),', page).group(1).replace("'", "")
    aid = re.search(' aid: (.*), //解密后的id', page).group(1)
    actual_page = int(re.search('actual_page: (.*),', page).group(1))  # 真实页数
    preview_page = int(re.search('preview_page: (.*),', page).group(1))  # 可预览页数
 
    if actual_page > preview_page:
        print("\n\033[31m该文档为限制文档，无法下载全部内容，请用vip+rmb，该问题无需反馈给开发者，他也不会解决！！\033[0m\n")
 
    output = title  # 输出文件（夹）
    print('解析成功. ')
    print('文档标题: ', title)
    # 接口每次会返回6个下载page地址
    list_pn = list(range(1, preview_page + 1, 6))
 
    # print(pngs)
    if filetype == 'pdf':
        pngs = {}
        print('解析到pdf文档, 准备开始解析下载..', end='')
        print('解析成功.\n正在获取pngs下载地址...')
        print('受接口限制，2s访问一次，请耐心等待所有接口信息返回')
 
        with alive_bar(len(list_pn), title='ing...') as bar:
            for pn in list_pn:
                bar()
                down_page_url = 'https://openapi.book118.com/getPreview.html?project_id=1&aid={}&view_token={}&page={}&_={}'.format(
                    aid, view_token, pn, str(int(time.time())))
                jsonpReturn = requests.get(url=down_page_url)
                page = re.search('jsonpReturn\((.*)\)', jsonpReturn.text).group(1)
                data_temp = json.loads(page)['data']
                # print(data_temp)
                pngs.update({x: data_temp[x] for x in data_temp})  # 这里有个bug，若返回值的url为空时，这里不会报错，但会造成下载png时异常，暂时没有考虑处理
                if pn != list_pn[-1]:
                    time.sleep(2)
 
        print('\n开始下载 jpg(s)...')
        pagenums = list(range(1, len(pngs) + 1))
 
        with alive_bar(len(pagenums), title='ing...') as bar:
            for i in range(len(pagenums)):
                bar()
                down_url = "https:" + pngs[str(i + 1)]
                request = requests.get(url=down_url, headers=png_headers)
                try:
                    page = request.content
                    with open(os.path.join(temp_dir, str(pagenums[i]) + '.jpeg'), 'wb') as f:
                        f.write(page)
                except:
                    continue
 
        print('\n开始合并图片成PDF...', end='')
 
        file_imgs = [os.path.join(temp_dir, str(i) + '.jpeg') for i in pagenums]
        # 不用以下代码会使img2pdf报错
        for img_path in file_imgs:
            with open(img_path, 'rb') as data:
                img = Image.open(data)
                # 将PNG中RGBA属性变为RGB，即可删掉alpha透明度通道
                img.convert('RGB').save(img_path)
 
        with open(output + '.pdf', 'wb') as f:
            f.write(img2pdf.convert(file_imgs))
 
        shutil.rmtree(temp_dir)
 
        print('下载成功.')
        print('保存到 ' + output + '.pdf')
    elif filetype in ['docx', 'doc']:
        pngs = {}
        print('解析到{}文档, 准备开始解析下载..'.format(filetype), end='')
        print('解析成功.\n正在获取pngs下载地址...')
        print('受接口限制，2s访问一次，请耐心等待所有接口信息返回')
        with alive_bar(len(list_pn), title='ing...') as bar:
            for pn in list_pn:
 
                down_page_url = 'https://openapi.book118.com/getPreview.html?&project_id=1&aid={}&t={}&view_token={}&page={}&_={}'.format(
                    aid, senddate, view_token, pn, str(int(time.time())))
                jsonpReturn = requests.get(url=down_page_url)
 
                page = re.search('jsonpReturn\((.*)\)', jsonpReturn.text).group(1)
                data_temp = json.loads(page)['data']
                # print(data_temp)
                bar()
                pngs.update({x: data_temp[x] for x in data_temp})
                if pn != list_pn[-1]:
                    time.sleep(2)
 
        print('\n开始下载 jpg(s)...')
        pagenums = list(range(1, len(pngs) + 1))
 
        with alive_bar(len(pagenums), title='ing...') as bar:
            for i in range(len(pagenums)):
                down_url = "https:" + pngs[str(i + 1)]
                request = requests.get(url=down_url, headers=png_headers)
                bar()
                try:
                    page = request.content
                    with open(os.path.join(temp_dir, str(pagenums[i]) + '.jpeg'), 'wb') as f:
                        f.write(page)
                except:
                    continue
 
        print('\n开始合并图片成PDF...', end='')
 
        file_imgs = [os.path.join(temp_dir, str(i) + '.jpeg') for i in pagenums]
        for img_path in file_imgs:
            with open(img_path, 'rb') as data:
                img = Image.open(data)
                # 将PNG中RGBA属性变为RGB，即可删掉alpha透明度通道
                img.convert('RGB').save(img_path)
 
        with open(output + '.pdf', 'wb') as f:
            f.write(img2pdf.convert(file_imgs))
 
        shutil.rmtree(temp_dir)
 
        print('下载成功.')
        print('保存到 ' + output + '.pdf')
 
    else:
        print('不支持的参数.文件类型:', filetype)
 
    temp_ = os.path.realpath(sys.argv[0])
    os.startfile(os.path.dirname(temp_))
    print("执行完成,继续下载请黏贴url，结束请关闭窗口\n")