Category: 技术折腾

有一天，当我坐在电脑前，思考着编程的奇妙之处时，一种冒险的感觉涌上心头。我想，为什么不用编程来探索互联网的深处，下载一些有趣的教材呢？于是，我开始了这次奇妙的编程之旅，带着好奇心和激情，我将向你展示如何使用Python编写一个多线程爬虫，用于下载各种教材的PDF文件。

准备工作

在我们踏上这次冒险之前，我们需要做一些准备工作。

初始化日志

首先，我们需要设置日志记录，以便随时跟踪我们的编程冒险。

import logging

def init_logging():
    logging_format = '%(asctime)s\t[%(levelname)s]\t[%(name)s]\t[%(threadName)s]\t%(message)s'
    logging.basicConfig(format=logging_format, level=logging.INFO)

导入必要的库

为了让我们的编程冒险变得更加容易，我们需要使用requests库来进行网络请求和数据下载。如果你还没有安装这个库，请使用以下命令来安装它：

pip install requests

设置下载目录和线程数量

这两个变量将在后面的代码中使用，你可以根据需要进行调整。

download_base_dir = 'd:/book3'  # 设置下载文件保存的文件夹
thread_count = 8  # 设置线程数量

开始编写爬虫

请求数据版本

首先，我们需要获取教材数据的版本信息，这将有助于我们确定要下载的文件。

def request_data_version() -> [str]:
    # 目标URL
    data_url = "https://s-file-1.ykt.cbern.com.cn/zxx/ndrs/resources/tch_material/version/data_version.json"
    try:
        logging.info("开始请求URL: %s", data_url)
        response = requests.get(data_url)
        logging.info("状态码 %s, 响应内容: %s", response.status_code, response.text)
        if response.status_code == 200:
            data = response.json()
            return data["urls"].split(",")
        else:
            logging.warning("无法获得正确的响应，程序退出 -1。")
            sys.exit(-1)
    except requests.exceptions.RequestException as e:
        logging.exception("请求数据版本失败", e)

请求单个数据URL

接下来，我们将请求每个教材的数据URL，并解析教材信息。

def request_single_data_url(data_url: str) -> [dict]:
    try:
        logging.info("开始请求URL: %s", data_url)
        response = requests.get(data_url)
        logging.info("状态码 %s", response.status_code)
        if response.status_code == 200:
            data = response.json()
            books = []
            for d in data:
                book_data = parse_book_data(d)
                if len(book_data) != 0:
                    books.append(book_data)
                else:
                    logging.warning("跳过此教材: %s", d['title'])
            return books
    except requests.exceptions.RequestException as e:
        logging.exception("请求单个数据URL失败", e)

解析教材数据

我们将解析每本教材的数据，包括教材名称和标签。

def parse_book_data(data: dict) -> dict:
    book_id = data['id']
    book_name = data['title']
    book_tags = data['tag_list']
    book_tags = sorted(book_tags, key=custom_sort_tag_list, reverse=True)
    if '版' not in (book_tags[0]['tag_name']):
        return {}
    return {"id": book_id, "name": book_name, "dirs": get_dirs_from_tags(book_tags)}

获取目录信息

我们将从标签中提取目录信息，以便稍后创建文件夹。

def get_dirs_from_tags(book_tags) -> str:
    return f"{book_tags[0]['tag_name']}/{book_tags[1]['tag_name']}/{book_tags[2]['tag_name']}"

自定义标签排序

为了确保我们获取的是正确的教材版本，我们需要自定义排序标签。

def custom_sort_tag_list(tag):
    tag_name = tag['tag_name']
    school_level, edition, grade, semester, course_name = '', '', '', '', ''
    if "版" in tag_name:
        edition = tag_name
    elif "年级" in tag_name:
        grade = tag_name
    elif "册" in tag_name:
        semester = tag_name
    elif '小学' in tag_name or '初中' in tag_name or '高中' in tag_name:
        school_level = tag_name
    elif '教材' not in tag_name:
        course_name = tag_name

    return edition, school_level, grade, course_name, semester

下载教材

最后，我们将下载每本教材的PDF文件。

def download_book(book):
    file_dir = f"{download_base_dir}/{book['dirs']}"
    file_name = f"{book['name']}.pdf"
    file_full_path = os.path.join(file_dir, file_name)
    logging.info("开始下载教材: %s/%s", file_dir, file_name)
    try:
        if not os.path.exists(file_dir):
            os.makedirs(file_dir)
    except FileExistsError:
        logging.warning("文件夹 %s 已经存在", file_dir)

    download_url = f"https://r1-ndr.ykt.cbern.com.cn/edu_product/esp/assets_document/{book['id']}.pkg/pdf.pdf"
    response = requests.get(download_url)
    if response.status_code == 200:
        with open(os.path.join(file_dir, file_name), "wb") as file:
            file.write(response.content)
            logging.info("教材下载成功: %s", file_full_path)
    else:
        logging.warning("教材下载失败，状态码: %s", response.status_code)

多线程下载

我们将使用多线程来提高下载速度。

def multi_thread_download

_books(shared_queue: queue.Queue):
    try:
        while True:
            item = shared_queue.get_nowait()
            download_book(item)
            shared_queue.task_done()
    except queue.Empty:
        logging.warning("队列为空")

请求所有教材

最后，我们将请求所有教材的信息并将其添加到共享队列中。

def request_all_books_to_shared_queue():
    shared_queue = queue.Queue(maxsize=3000)
    urls = request_data_version()
    for url in urls:
        books = request_single_data_url(url)
        for book in books:
            shared_queue.put(book)
    return shared_queue

执行下载

现在，我们已准备好执行下载任务。

if __name__ == '__main__':
    init_logging()

    # 下载文件保存的文件夹
    download_base_dir = 'd:/book3'
    # 线程数量
    thread_count = 8

    all_books_queue = request_all_books_to_shared_queue()
    with concurrent.futures.ThreadPoolExecutor(max_workers=thread_count) as executor:
        futures = [executor.submit(multi_thread_download_books, all_books_queue) for i in range(thread_count)]
        concurrent.futures.wait(futures)

    logging.info("完成下载!!!")

结束语

通过这个教程，你已经学会了如何使用Python编写一个多线程爬虫，用于下载各种教材的PDF文件。这个项目不仅展示了编程的实际应用，还提供了深入探索网络资源的机会。希望你能充分利用这些技能，探索更多有趣的项目和挑战！

在现代社交网络和电子通信的时代，电子邮件仍然是一种重要的沟通工具。无论是向客户发送营销邮件，还是向团队成员发送通知，自动化发送批量邮件是提高效率的关键。在本教程中，我们将学习如何使用Python编写一个自动发送批量邮件的脚本。

背景故事

假设你是一名市场营销专家，你需要向数百位潜在客户发送个性化的邮件，以推广你的产品或服务。手动一个一个发送邮件将是一项繁琐且耗时的任务。但是，有了Python的帮助，你可以轻松地自动化这个过程，将你的邮件发送到每个收件人。

准备工作

在我们开始之前，让我们先进行一些准备工作：

1. SMTP邮箱设置：你需要一个支持SMTP（Simple Mail Transfer Protocol）的邮箱，例如Gmail或QQ邮箱。确保开启SMTP服务，并获取SMTP服务器地址和端口号以及你的发件人邮箱和密码。

2. CSV收件人列表：将你要发送邮件的收件人列表保存为CSV文件，每行一个邮箱地址。这个列表可以包含数百个收件人。

使用Python编写自动发送邮件脚本

我们将使用Python编写一个脚本，它将完成以下任务：

1. 连接SMTP服务器：与SMTP服务器建立连接，使用TLS协议进行安全连接。

2. 登录邮箱：使用你的发件人邮箱和密码登录SMTP服务器。

3. 构造邮件内容：创建一封包含主题、正文、图片和附件的邮件。

4. 发送邮件：将邮件发送给收件人。

以下是Python代码的主要部分：

import smtplib
import csv
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage

def send_email(sender_email, sender_password, receiver_email):
    # 与SMTP服务器建立连接
    smtp_server = 'smtp.qq.com'
    server_port = 587
    server = smtplib.SMTP(smtp_server, server_port)
    server.starttls()

    try:
        # 登录邮箱账号
        server.login(sender_email, sender_password)

        # 构造邮件内容
        msg_root = MIMEMultipart('related')
        msg_root['Subject'] = '测试一下'
        msg_root['From'] = sender_email
        msg_root['To'] = receiver_email

        subject = '测试一下111111'
        message = '''
        <html>
          <body>
            <p><img src="cid:image1" alt="升学教育图片" style="width:300px;height:200px;"></p>
            <p>班上新来一位学生，名字叫“马騳骉”。</p>
            <p>开学点名了，班主任不知怎么念，就说 : 马叉叉到了没?</p>
            <p>语文老师有点文学素养，点名道：万马奔腾到了没?</p>
          </body>
        </html>
        '''

        # 添加文本内容
        html_part = MIMEText(message, 'html')
        msg_root.attach(html_part)

        # 添加图片附件
        with open('path/to/your/image.jpg', 'rb') as image_file:
            image_part = MIMEImage(image_file.read())
            image_part.add_header('Content-Disposition', 'attachment; filename=image.jpg')
            image_part.add_header('Content-ID', '<image1>')
            msg_root.attach(image_part)

        # 添加附件
        with open('path/to/your/attachment.pdf', 'rb') as file:
            attachment_part = MIMEApplication(file.read(), Name='attachment.pdf')
            attachment_part.add_header('Content-Disposition', 'attachment; filename=attachment.pdf')
            msg_root.attach(attachment_part)

        # 发送邮件
        server.sendmail(sender_email, receiver_email, msg_root.as_string())
        print(f"邮件发送成功: {receiver_email}")
    except smtplib.SMTPException as e:
        print(f"邮件发送失败: {receiver_email}，错误信息: {str(e)}")

    # 关闭连接
    server.quit()

# 创建收件人邮箱列表
receiver_emails = []

# 读取CSV文件并获取收件人邮箱列表
with open('path/to/your/email.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        receiver_emails.append(row[0])

# 循环发送邮件给收件人列表中的每个邮箱
for receiver_email in receiver_emails:
    send_email(sender_email, sender_password, receiver_email)

批量发送邮件

要批量发送邮件，我们将创建一个函数 send_emails，它将循环遍历收件人列表，并在每个邮箱上启动一个线程以异步发送邮件。这可以大大提高邮件发送速度。

以下是如何批量发送邮件的代码：

import threading

def send_emails(sender_email, sender_password, thread_count):
    # 创建线程列表
    threads = []

    # 创建发送邮件的函数
    def send_email_thread(receiver_email):
        send_email(sender_email, sender_password, receiver_email)

    # 创建并启动发送邮件的线程
    for receiver_email in receiver_emails:
        t = threading.Thread(target=send_email_thread, args=(receiver_email,))
        threads.append(t)
        t.start()

        # 控制最大线程数
        if len(threads) >= thread_count:
            for thread in threads:
                thread.join()
            threads = []

    # 等待剩余线程完成
    for thread in threads:
        thread.join()

# 调用批量发送邮件函数
send_emails(sender_email, sender_password, thread_count)

结论

通过使用Python编写自动发送批量邮件的脚本，我们可以轻松地将邮件发送给大量收件人，提高工作效率。无论是市场营销还是通知，这个自动化方法都可以帮助你节省时间和精力。

希望这篇教程对你有所帮助！如果你有任何问题或需要进一步的指导，请随时联系我们。

你是否曾经担心过将重要文件存储在电脑上，担心它们可能被他人访问或丢失？在本教程中，我们将介绍如何使用Python编写一个自动化脚本，将文件夹中的文件压缩、加密，并安全地删除原始文件，以保护你的数据。让我们一起来看看如何做到这一点！

背景故事

假设你有一个包含敏感文件的文件夹，你希望将这些文件压缩并加密，以确保它们不会被未经授权的人访问。同时，你也想要删除原始文件，以释放磁盘空间并减少风险。这个任务可能会变得非常繁琐，但幸运的是，我们可以使用Python来自动化这个过程。

准备工作

在我们深入讨论代码之前，让我们先了解一些准备工作。首先，我们需要确保你的计算机上安装了WinRAR软件，因为我们将使用它来进行文件的压缩和加密。另外，你需要提供一个密码，用于加密压缩文件。

使用Python编写自动化脚本

我们将使用Python编写一个自动化脚本，执行以下操作：

1. 压缩文件夹：我们将使用WinRAR来压缩文件夹中的文件，创建一个加密的压缩文件。

2. 加密压缩文件：我们将设置密码来加密压缩文件，确保只有知道密码的人才能解压文件。

3. 删除原始文件：一旦文件成功压缩并加密，我们将安全地删除原始文件夹中的文件，以保护数据。

以下是Python代码的主要部分：

import shutil
import subprocess
import os
import time
from pathlib import Path

def encrypt_folder_with_winrar(folder_path, password):
    # WinRAR命令
    winrar_command = r'C:\Program Files\WinRAR\WinRAR.exe'

    # 获取当前日期
    current_date = time.strftime("%Y-%m-%d", time.localtime())

    # 获取桌面BD文件夹路径
    desktop_path = str(Path.home() / "Desktop")
    bd_folder_path = os.path.join(desktop_path, "DB")

    # 创建DB文件夹（如果不存在）
    if not os.path.exists(bd_folder_path):
        os.mkdir(bd_folder_path)

    # 压缩包文件名
    compressed_filename = f'压缩包-{current_date}.rar'

    # 压缩包路径
    compressed_filepath = os.path.join(bd_folder_path, compressed_filename)

    # 加密命令
    encryption_command = [winrar_command, 'a', '-r', '-hp' + password, compressed_filepath, folder_path]

    # 执行加密命令
    subprocess.run(encryption_command)

    return compressed_filepath

def encrypt_and_delete_folder(folder_path, password):
    try:
        # 压缩并加密文件夹
        compressed_file = encrypt_folder_with_winrar(folder_path, password)

        # 等待一段时间，确保压缩文件完成
        time.sleep(10)

        # 删除源文件夹中的文件
        for root, dirs, files in os.walk(folder_path):
            for file in files:
                os.remove(os.path.join(root, file))

        print("加密打包操作成功")
    except Exception as e:
        print(f"加密打包操作失败：{e}")

        # 出现错误时，删除已创建的压缩文件
        if os.path.exists(compressed_file):
            os.remove(compressed_file)
            print("压缩文件已删除.")

# 文件夹路径
folder_path = r'D:\BACK'

# 密码
password = '123456'

# 加密并删除文件夹中的文件
encrypt_and_delete_folder(folder_path, password)

使用定时任务自动化操作

如果你希望定期执行这个操作，我们可以使用Python的schedule库来安排任务。在上述代码中，我们创建了一个名为encrypt_and_delete_folder的函数，它将压缩、加密和删除文件夹中的文件。然后，我们使用schedule库来定期执行这个函数。

以下是如何设置定时任务的代码：

import schedule
import time

# 文件夹路径
folder_path = r'D:\BACK'

# 密码
password = '123456'

# 每天定时执行加密打包操作
schedule.every().day.at("12:20").do(encrypt_and_delete_folder, folder_path=folder_path, password=password)

# 循环执行任务，并写入日志
while True:
    schedule.run_pending()
    time.sleep(60)

结论

通过使用Python编写自动化脚本和定时任务，我们成功地实现了文件夹中文件的

压缩、加密和删除操作。这种自动化方法可以帮助你更好地保护你的敏感数据，同时也节省了你的时间和精力。

希望这篇教程对你有所帮助，如果你有任何疑问或需要进一步的指导，请随时联系我们。保持数据安全，保持自动化！

在这个教程中，我们将介绍如何使用克拉默法则解决一个有趣的罗盘谜题。这个谜题涉及三个旋转的圆盘，每个圆盘都可以按照不同的规则旋转，目标是将它们都旋转到特定的角度。我们将使用克拉默法则来解决这个谜题，找到满足条件的解。让我们开始吧！

背景故事

想象一下，你被困在一个神秘的房间里，房间的中心有一个奇怪的装置，上面有三个旋转的圆盘。每个圆盘都有不同的旋转规则，包括旋转方向和步长。你的任务是将这三个圆盘都旋转到角度为180度的位置，但是你不知道如何操作这些圆盘。

幸运的是，你有一本关于克拉默法则的笔记，你决定使用这个方法来解决这个问题。你开始分析每个圆盘的旋转规则和它们之间的联动规则，然后使用克拉默法则计算出每个圆盘需要旋转的次数，最终找到了解决这个谜题的方法。

罗盘谜题

这个罗盘谜题涉及三个圆盘，分别是内圈、中圈和外圈。每个圆盘都有以下属性：

• 旋转方向：可以是逆时针或顺时针。
• 旋转步长：用亮着的星星数量表示。
• 初始角度：以角度/60的值表示。

除此之外，还有联动规则，规定了哪些圆盘会联动旋转，哪些不会。这些规则以列表的形式给出，其中0表示内圈，1表示中圈，2表示外圈，-1表示不联动。

使用克拉默法则解决问题

要解决这个罗盘谜题，我们可以使用克拉默法则，该方法通常用于解决线性方程组。我们将每个圆盘的旋转次数表示为x、y和z，然后设置以下方程：

• 内圈旋转次数：存在(self.coordination[0], 0) x + 存在(self.coordination[1], 0) y + 存在(self.coordination[2], 0) * z = 计算(self.disk[0][“init”], self.disk[0][“direction”], self.disk[0][“rotate”])
• 中圈旋转次数：存在(self.coordination[0], 1) x + 存在(self.coordination[1], 1) y + 存在(self.coordination[2], 1) * z = 计算(self.disk[1][“init”], self.disk[1][“direction”], self.disk[1][“rotate”])
• 外圈旋转次数：存在(self.coordination[0], 2) x + 存在(self.coordination[1], 2) y + 存在(self.coordination[2], 2) * z = 计算(self.disk[2][“init”], self.disk[2][“direction”], self.disk[2][“rotate”])

这些方程中的系数矩阵可以用克拉默法则来解决，我们首先计算原行列式值D。然后，我们可以通过遍历的方式，找到满足整数解和非负解的x、y和z。这将是解决罗盘谜题的答案。

下面是用Python实现的代码和算法：

import copy

class CompassPuzzleSolver:
    def __init__(self):
        # 初始化罗盘信息...
        # 省略了与文章中相同的初始化部分
        # ...

    # 计算到达180度所需的次数
    @staticmethod
    def count(angle: int, direction: int, rotate: int) -> int:
        b = 0
        while True:
            if angle % 180 == 0 and angle % 360 != 0:
                return b
            else:
                angle = angle - direction * rotate
                b += 1

    # 行列式计算
    @staticmethod
    def calculate(matrix_temp: list, replace: list = [], index: int = -1) -> int:
        matrix = copy.deepcopy(matrix_temp)
        if index != -1:
            matrix[0][index], matrix[1][index], matrix[2][index] = replace[0], replace[1], replace[2]
        return \
        matrix[0][0] * matrix[1][1] * matrix[2][2] + \
        matrix[0][1] * matrix[1][2] * matrix[2][0] + \
        matrix[0][2] * matrix[1][0] * matrix[2][1] - \
        matrix[0][2] * matrix[1][1] * matrix[2][0] - \
        matrix[0][1] * matrix[1][0] * matrix[2][2] - \
        matrix[0][0] * matrix[1][2] * matrix[2][1]

    # 答案计算主程序
    def solve_puzzle(self) -> bool:
        # 最终目标：三圈状态均为180
        # x, y, z 三个变量，分别对应三个联动规则所需次数
        # ...

        # 使用克拉默法则计算...
        # 省略了计算部分的代码
        # ...

        # 找到满足条件的解
        # 省略了遍历部分的代码
        # ...

# 创建罗盘谜题解决器对象
solver = CompassPuzzleSolver()
# 解决谜题并打印答案
if solver.solve_puzzle():

 print("成功找到解决罗盘谜题的方法！")
else:
    print("未找到解决罗盘谜题的方法。")

结论

通过使用克拉默法则和Python编程，我们成功解决了这个有趣的罗盘谜题，找到了每个圆盘需要旋转的次数。这个方法可以用于解决类似的问题，其中涉及多个变量和约束条件。

如果你也喜欢解决谜题和挑战性的问题，不妨尝试一下这个罗盘谜题，看看你能否找到更快的解决方法！

希望这篇教程对你有所帮助，如果你对克拉默法则或其他数学方法有更多的兴趣，请继续关注我的博客，我们将继续分享有趣的数学和科学知识。