Python代码

import re
import os
import requests
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service

url = 'https://www.taobao.com/'
header={'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) \
        AppleWebKit/537.36 (KHTML, like Gecko) \
        Chrome/35.0.1916.114 Safari/537.36'}
options = Options()
options.add_experimental_option("debuggerAddress", "127.0.0.1:12306")
service_ = Service(executable_path=r'I:\chromedriver_win64\chromedriver.exe',port=0)
driver = webdriver.Chrome(service=service_)
driver.get(url)
driver.maximize_window()

def get_content(i):
    img = driver.find_element(by='xpath',
                              value='/html/body/div[6]/div/div/div/div/div[%d]/a/div[1]/img' % i).get_attribute(
        'src')
    img_response = requests.get(img,headers=header)
    img_name = "%d.jpg" % i
                # 判断taobao_img文件夹是否存在
    if ~os.path.exists('taobao_img'):
        os.mkdir('taobao_img')
    with open('taobao_img/' + img_name, mode='wb') as f:
        f.write(img_response.content)
    f.close()
    g = open('taobao.csv', mode='a', encoding='utf-8')
    title = driver.find_element(by='xpath',
                                value='/html/body/div[6]/div/div/div/div/div[%d]/a/div[2]/div' % i).get_attribute(
        'innerHTML')
    title = title.replace(
        '<img src="//img.alicdn.com/imgextra/i1/O1CN01rHZjwm1kc1MDCvBIO_!!6000000004703-2-tps-38-20.png">','')
    g.write(title)
    price = driver.find_element(by='xpath',
                                value='/html/body/div[6]/div/div/div/div/div[%d]/a/div[3]' % i).get_attribute(
        'innerHTML')
    price = price.strip()

    if re.match('<span class="price-value"><em>¥</em>', price):
        price = price.strip('<span class="price-value"><em>¥</em>')
        price = price.replace("</span>", "")
        g.write(',' + price + '\n')
        g.close()

print("----程序至少运行60秒，请耐心等待------")

# 滚动使页面加载完成
for i in range(2000):
    driver.execute_script('scrollTo(0,%d)' % (i * 10))

open('taobao.csv', mode='w', encoding='utf-8')
for i in range(1, 300):  # 300为最大数，不可更大
    get_content(i)

print('运行结束')

这段代码是一个使用 PyQt5（一个 Python 的 GUI 库）编写的桌面应用程序，用于汇总多个 Excel 文件中的数据到一个新的 Excel 文件中。让我来为你解析一下代码的主要部分：

1. 首先，导入了必要的模块和库：

   import sys
   import os
   from PyQt5 import QtWidgets
   from PyQt5.QtGui import QIcon
   import xlrd
   import datetime
   import time
   from openpyxl import Workbook
   from openpyxl.styles import Border, Side, PatternFill, Font, GradientFill, Alignment

2. 创建了一个继承自 QtWidgets.QMainWindow 的类 MainGUI，用于构建 GUI 界面。
3. 在 MainGUI 类中，初始化了应用程序窗口、设置了窗口标题和初始大小，并创建了主要的窗口部件。
4. 主要窗口部件包括两个文本输入框 self.input 和 self.output，两个按钮 self.input_btn 和 self.output_btn 用于选择输入和输出文件夹，一个列表部件 self.show_result 用于显示操作结果，以及一个按钮 self.run 用于执行数据汇总操作。
5. 绑定了按钮的点击事件，分别调用了 Choice_dir_input、Choice_dir_output 和 Summary_data 函数。
6. Choice_dir_input 和 Choice_dir_output 函数通过调用 QtWidgets.QFileDialog.getExistingDirectory 弹出文件夹选择对话框，让用户选择输入和输出文件夹，并将选择的文件夹路径显示在文本输入框中。
7. Get_data 函数用于从单个 Excel 文件中提取数据，使用 xlrd 库来读取 Excel 文件。
8. Get_file_path 函数用于获取指定文件夹下所有的 .xls 文件。
9. Get_current_time 函数用于获取当前的日期和时间。
10. Summary_data 函数是核心功能，用于汇总多个 Excel 文件的数据到一个新的 Excel 文件中。它会调用前面的函数来获取数据，然后使用 openpyxl 库创建一个新的 Excel 工作簿，将数据写入工作表，并设置单元格样式。
11. 最后，在 main 函数中创建了应用程序对象，设置应用程序图标，创建 MainGUI 窗口对象，并启动应用程序的事件循环。

这段代码是一个简单的桌面应用程序，用于处理 Excel 文件数据的汇总，通过 GUI 提供了文件选择和操作结果显示的功能。

import sys
import os
from PyQt5 import QtWidgets
from PyQt5.QtGui import QIcon
import xlrd
import datetime
import time
from openpyxl import Workbook
from openpyxl.styles import Border, Side, PatternFill, Font, GradientFill, Alignment
 
class MainGUI(QtWidgets.QMainWindow):
    def __init__(self):
        super().__init__()        
        self.setWindowTitle("领料明细汇总")
        self.resize(800, 400)
        self.main_widget = QtWidgets.QWidget()        
        self.main_widget_layout = QtWidgets.QGridLayout()
        self.main_widget.setLayout(self.main_widget_layout)
 
        self.input = QtWidgets.QLineEdit()
        self.input_btn = QtWidgets.QPushButton("选择输入文件夹")
        self.output = QtWidgets.QLineEdit()
        self.output_btn = QtWidgets.QPushButton("选择输出文件夹")
        self.show_result = QtWidgets.QListWidget()
        self.run = QtWidgets.QPushButton("执行汇总")
 
        self.main_widget_layout.addWidget(self.input,0,0,1,2)
        self.main_widget_layout.addWidget(self.input_btn, 0, 2, 1, 1)
        self.main_widget_layout.addWidget(self.output,1,0,1,2)
        self.main_widget_layout.addWidget(self.output_btn, 1, 2, 1, 1)
        self.main_widget_layout.addWidget(self.run, 2, 2, 1, 1)
        self.main_widget_layout.addWidget(self.show_result, 3, 0, 3, 3)
 
        self.setCentralWidget(self.main_widget)
         
        self.input_btn.clicked.connect(self.Choice_dir_input) #将"选择输入文件夹"按钮绑定Choice_dir_input函数
        self.output_btn.clicked.connect(self.Choice_dir_output) #将"选择输出文件夹"按钮绑定Choice_dir_output函数
        self.run.clicked.connect(self.Summary_data) #“执行汇总”按钮绑定Summary_data函数
 
    def Choice_dir_input(self):
        #选择目录操作
        dir_path = QtWidgets.QFileDialog.getExistingDirectory(self, "请选择文件夹路径", "D:\\")
        #将选择的目录显示在文本编辑框中
        self.input.setText(dir_path)
         
    def Choice_dir_output(self):
        dir_path = QtWidgets.QFileDialog.getExistingDirectory(self, "请选择文件夹路径", "D:\\")
        self.output.setText(dir_path)
         
    def Get_data(self, file):
        '''获取单个Excel文件中的资料'''
        wb = xlrd.open_workbook(file)
        ws = wb.sheets()[0]
        data = {}
        for row in range(7, ws.nrows-2):
            card_id = ws.cell(2, 16).value
            car = ws.cell(3, 16).value
            dt = ws.cell(row, 0).value
            if type(dt) is float:
                date_time = xlrd.xldate.xldate_as_datetime(dt, 0)
            else:
                date_time = datetime.datetime.strptime(dt,'%Y-%m-%d %H:%M:%S')
            business = ws.cell(row, 2).value
            model = ws.cell(row, 3).value
            qty = ws.cell(row, 4).value
            unit_price = ws.cell(row, 6).value
            price = ws.cell(row, 8).value
            reward = ws.cell(row, 9).value
            discount = ws.cell(row, 11).value
            balance = ws.cell(row, 13).value
            location = str(ws.cell(row, 15).value).strip()
            operator = ws.cell(row, 17).value
            date = date_time.date()
            time = date_time.time()
            info_list=[card_id,car,date_time,business,model,qty,unit_price,price,reward,discount,
                       balance,location,operator,date,time]
            data.setdefault(date,[])
            if info_list[3] != "备注":
                data[date].append(info_list)
        #增加当日加油次数        
        for key in data.keys():
            for i in data[key]:
                i.append(len(data[key]))
        return data
     
    def Get_file_path(self,path):        
        files=[]
        for file in os.listdir(path):
            if file.endswith(".xls"): #排除文件夹内的其它干扰文件
                files.append(path+"\\"+file)
        return files
     
    def Get_current_time(self):
        time_stamp = time.time()  # 当前时间的时间戳
        local_time = time.localtime(time_stamp)  #
        str_time = time.strftime('%Y-%m-%d %H.%M.%S', local_time)
        return str_time
     
    def Summary_data(self,files):
        thin = Side(border_style="thin", color="000000")#定义边框粗细及颜色
        title = ['部门', '部门编号', '时间', '业务类型', '品种', '数量', '单价', '金额', '额外值',
         '调整', '剩余', '库位', '操作员', '领取日期', '领取时间', '领取次数']
 
        wb = Workbook() 
        ws = wb.active
        ws.merge_cells("A1:P1")
        ws.cell(1,1).value = "领料明细汇总表"
        ws.cell(1,1).font = Font(name=u'黑体',bold=True,size=18)
        ws.row_dimensions[1].height  = 22.2
        ws.cell(1,1).alignment = Alignment(horizontal="center", vertical="center")
        ws.append(title)
 
        #插入数据
        files = self.Get_file_path(self.input.text()) #获取文本编辑框中的输入文件目录，并获取目录下的xls文件
        for file in files:
            data = self.Get_data(file)
            for key in data.keys():
                for i in data[key]:
                    ws.append(i)
            f = QtWidgets.QListWidgetItem(f"{file} 的内容已加入总表.") # 创建一个显示项
            self.show_result.addItem(f) # 将结果添加到部件中
 
        #设置字号，对齐，缩小字体填充，加边框
        #Font(bold=True)可加粗字体
        for row_number in range(2, ws.max_row+1):
            for col_number in range(1,17):
                c = ws.cell(row=row_number,column=col_number)
                c.font = Font(size=9)
                c.border = Border(top=thin, left=thin, right=thin, bottom=thin)
                c.alignment = Alignment(horizontal="left", vertical="center")
 
        col_name= list("ABCDEFGHIJKLMNOP")
        col_width = [8, 8, 16, 8, 16, 8, 8, 9.8, 8, 8, 8, 11, 8.3, 9, 8, 8]
        for i in range(len(col_name)):
            ws.column_dimensions[col_name[i]].width = col_width[i]
 
        ws.column_dimensions.group('I','K',hidden=True)
        ws.column_dimensions.group('N','O',hidden=True)
 
        wb.save(f"{self.output.text()}\\领料明细汇总表{self.Get_current_time()}.xlsx")
        f = QtWidgets.QListWidgetItem(f"\n领料明细汇总表{self.Get_current_time()}.xlsx 已生成，请去输出文件夹查看.") # 创建一个显示项
        self.show_result.addItem(f) # 将结果添加到部件中
 
             
def main():
    app = QtWidgets.QApplication(sys.argv)
    app.setWindowIcon(QIcon("PO.ico"))#设置界面左上角图标
    gui = MainGUI()
    gui.show()
    sys.exit(app.exec_())
 
 
if __name__ == '__main__':
    main()

这段代码用于生成指定格式的虚拟手机号码，并将这些手机号码保存到一个文本文件中。下面是代码的主要功能和逻辑：

1. generate_phone_number(province, prefix, suffix) 函数用于生成一个虚拟手机号码，其中 province 表示省份代码，prefix 表示前三位号段，suffix 表示后两位号码。生成的号码格式为 province-prefix-6位随机数字-suffix。
2. generate_unique_phone_numbers(num_numbers, province, prefix, suffix) 函数用于生成指定数量的唯一虚拟手机号码。它通过调用 generate_phone_number 函数生成号码，并使用集合 phone_numbers 来确保生成的号码唯一。直到集合中的号码数量达到指定的 num_numbers 时，循环生成号码。
3. save_phone_numbers_to_file(phone_numbers, filename) 函数用于将生成的手机号码保存到指定的文本文件中。它遍历 phone_numbers 列表，并将每个号码写入文件中，每行一个号码。
4. 在代码中设置了自定义的省份代码 (custom_province)、前三位号段 (custom_prefix) 和后两位号码 (custom_suffix)。
5. 调用 generate_unique_phone_numbers 生成了 100 个唯一的虚拟手机号码，并将它们保存到名为 “phone_numbers.txt” 的文本文件中。

最终，代码会在控制台上输出 “Generated Unique Phone Numbers saved to phone_numbers.txt”，指示已生成并保存虚拟手机号码。如果输入的号码格式不正确，则会输出 “Error: Invalid input”。

完整的源码如下：

import random

def generate_phone_number(province, prefix, suffix):
    if len(province) != 2 or len(prefix) != 3 or len(suffix) != 2:
        return None
   
    middle_digits = ''.join(str(random.randint(0, 9)) for _ in range(6))
    phone_number = f"{province}-{prefix}-{middle_digits}-{suffix}"
    return phone_number

def generate_unique_phone_numbers(num_numbers, province, prefix, suffix):
    phone_numbers = set()
    while len(phone_numbers) < num_numbers:
        phone_number = generate_phone_number(province, prefix, suffix)
        if phone_number:
            phone_numbers.add(phone_number)
    return list(phone_numbers)

def save_phone_numbers_to_file(phone_numbers, filename):
    with open(filename, 'w') as file:
        for number in phone_numbers:
            file.write(number + '\n')

custom_province = "HE"  #省份代码
custom_prefix = "151"   # 前三位
custom_suffix = "27"    # 后二位
output_file = "phone_numbers.txt"

generated_numbers = generate_unique_phone_numbers(100, custom_province, custom_prefix, custom_suffix)
if generated_numbers:
    save_phone_numbers_to_file(generated_numbers, output_file)
    print("Generated Unique Phone Numbers saved to", output_file)
else:
    print("Error: Invalid input")

你可以将这段代码保存为一个 `.py` 文件，然后运行它。运行后，它将生成并保存指定数量的虚拟手机号码到名为 “phone_numbers.txt” 的文本文件中。确保设置了 `custom_province`、`custom_prefix` 和 `custom_suffix` 来自定义号码的格式。

这段代码用于分析图像中的颜色信息并根据颜色值的平均值来判断是接近黄色还是接近紫色。具体步骤如下：

1. 读取图像：

• 使用OpenCV的cv2.imread方法读取指定路径下的图像。

1. 定义需要识别的颜色及其阈值范围：

• 颜色以RGB颜色空间的阈值范围表示，存在一个颜色字典color_dist，其中包括了需要识别的颜色（’pink’和’yellow’）及其对应的阈值范围。

1. 对图像进行高斯模糊和颜色空间转换：

• 使用高斯模糊来平滑图像。
• 将图像从BGR颜色空间转换为HSV颜色空间，以便更好地处理颜色信息。

1. 使用腐蚀操作：

• 使用cv2.erode方法对HSV图像进行腐蚀操作，以消除噪点，使边缘更加清晰。

1. 查找颜色区域块：

• 针对每个需要识别的颜色，使用cv2.inRange方法找到在阈值范围内的颜色区域。
• 使用cv2.findContours方法查找颜色区域的轮廓。

1. 获取最大颜色区域：

• 从所有颜色区域中选择面积最大的区域，将其用矩形框出。

1. 随机生成20个点位：

• 随机生成20个点位坐标，用于计算平均颜色值。

1. 计算20个点位的平均颜色值：

• 遍历这些点位，获取每个点位的颜色值，然后计算这些颜色值的平均值。

1. 判断平均颜色值接近哪种颜色：

• 通过计算平均颜色值与黄色和紫色的颜色距离，判断平均颜色值接近哪种颜色。

1. 输出结果：

• 根据颜色判断结果，输出是阴性还是阳性。
• 绘制矩形框和随机点位到图像上，以可视化显示结果。

1. 显示图像：
   • 使用OpenCV的窗口来显示处理后的图像。

代码中的cv2.namedWindow和cv2.imshow方法用于创建窗口并显示图像。最终，根据平均颜色值的判断结果，会在控制台输出相应信息，并在图像上绘制矩形框和随机点位以可视化显示结果。

import cv2
import numpy as np
 
# 读取图像
# image = cv2.imread("./test.png")
image = cv2.imread("./t2.jpg")
ball_color = ['yellow', 'pink'] # 需要识别的颜色 支持多个颜色
color_dist = {
    'pink': {'Lower': np.array([150, 43, 46]), 'Upper': np.array([175, 255, 255])},
    'yellow': {'Lower': np.array([21, 43, 46]), 'Upper': np.array([34, 255, 255])},
    'purple': {'Lower': np.array([125, 43, 46]), 'Upper': np.array([155, 255, 255])}
}
 
gs_frame = cv2.GaussianBlur(image, (5, 5), 0)  # 高斯模糊
hsv = cv2.cvtColor(gs_frame, cv2.COLOR_BGR2HSV)  # 转化成HSV图像
erode_hsv = cv2.erode(hsv, None, iterations=2)  # 腐蚀 粗的变细
colorArr = []
for colorValue in ball_color: #获取所有匹配的区域块
    inRange_hsv = cv2.inRange(erode_hsv, color_dist[colorValue]['Lower'], color_dist[colorValue]['Upper'])
    c = cv2.findContours(inRange_hsv.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]
    colorArr += c
mask = max(colorArr, key=cv2.contourArea) #获取最大色块
rect = cv2.minAreaRect(mask)
box = cv2.boxPoints(rect)
box = np.intp(box)
 
# 计算边界框的中心点坐标
center_x = int((box[0][0] + box[2][0]) / 2)
center_y = int((box[0][1] + box[2][1]) / 2)
 
# 随机生成20个点位
points = []
for _ in range(20):
    x = np.random.randint(center_x - 8, center_x + 8)
    y = np.random.randint(center_y - 8, center_y + 8)
    points.append((x, y))
 
# 计算20个点位的平均颜色值
avg_color = np.zeros(3)
for point in points:
    color = hsv[point[1], point[0]]
    avg_color += color
avg_color = tuple(map(int, avg_color / len(points)))
 
# 打印平均颜色值
print("平均颜色值：", avg_color)
 
# 判断平均颜色值接近黄色还是接近紫色
yellow_dist = np.linalg.norm(avg_color - color_dist['yellow']['Lower'])
purple_dist = np.linalg.norm(avg_color - color_dist['purple']['Lower'])
 
# 接口应在这里返回结果
if yellow_dist < purple_dist:
    print("平均颜色值接近黄色----阴性")
 
else:
    print("平均颜色值接近紫色----阳性")
 
# 绘制矩形和随机点位
cv2.drawContours(image, [np.intp(box)], -1, (0, 255, 255), 2)
for point in points:
    cv2.circle(image, point, 3, (0, 0, 255), -1)
 
# 显示图像
cv2.namedWindow("img", cv2.WINDOW_NORMAL | cv2.WINDOW_KEEPRATIO)
cv2.imshow('img', image)
cv2.waitKey(0)

这段代码用于从网页上抓取数据，并将数据保存到文本文件中。主要步骤如下：

1. 发送HTTP请求获取网页内容：

• 使用requests.get方法发送GET请求，获取指定网页的HTML内容。

1. 使用XPath解析HTML内容：

• 使用lxml库的etree.HTML方法将HTML文本解析成HTML树。
• 使用XPath表达式定位网页中的数据。

1. 遍历HTML元素获取数据：

• 使用XPath表达式选中需要抓取的数据元素。
• 遍历每个元素，提取城市、辐射值和检测时间等数据。
• 将提取的数据构建成字典，并将字典添加到名为datas的列表中。

1. 写入数据到文本文件：

• 打开一个文本文件以写入模式，文件名格式为data_日期.txt。
• 遍历datas列表，将每个数据字典的内容格式化为字符串，并写入文本文件。
• 使用datetime.datetime.now().strftime("%Y%m%d")获取当前日期作为文件名的一部分。

总体来说，这段代码通过HTTP请求和XPath解析，从指定网页上抓取了数据，然后将数据保存到文本文件中，文件名包括日期信息。

import datetime
import time
 
import requests
from lxml import etree
 
response = requests.get('https://data.rmtc.org.cn/gis/listtype0M.html')
html_parse = etree.HTML(response.text)
lis = html_parse.xpath('//*[@class="datali"]')
datas = []
for li in lis:
    hr_url = li.xpath('.//div[@class="divname"]/a/@href')[0]
    hr_name = (li.xpath('.//div[@class="divname"]/a/text()')[0].replace('\r', '')
               .replace('\n', '')
               .replace('\t', '').strip())
    city = hr_name.split('(')[0]
    time.sleep(0.2)
    response = requests.get(f'https://data.rmtc.org.cn/gis/{hr_url}')
    html_children_parse = etree.HTML(response.text)
    children_lis = html_children_parse.xpath('//*[@class="datali"]')
    for cl in children_lis:
        hr_children_name = (cl.xpath('.//div[@class="divname"]/text()')[0].replace('\r', '')
                            .replace('\n', '')
                            .replace('\t', '').strip())
        hr_children_val = cl.xpath('.//div[@class="divval"]/span[@class="label"]/text()')[0]
        hr_children_time = cl.xpath('.//div[@class="divval"]/span[@class="showtime"]/text()')[0]
        datas.append({'province': city.strip(), 'city': hr_children_name, 'val': hr_children_val, 'check_time': hr_children_time})
    time.sleep(0.2)
 
with open(f'data_{datetime.datetime.now().strftime("%Y%m%d")}.txt', 'wt', encoding='UTF-8') as f:
    for d in datas:
        f.write(f'城市：{d["province"]}-{d["city"]}，辐射值：{d["val"]}，检测时间：{d["check_time"]}\r\n')

这段代码是一个用于批量下载青少年读本文件的脚本，它使用了多线程的方式进行文件下载。以下是代码的主要功能和流程：

1. 导入所需模块：导入了requests、os和ThreadPoolExecutor模块。
2. 定义青少年读本文件列表URL：url变量存储了获取青少年读本文件列表的URL。
3. 定义下载目录：download_dir变量存储了下载文件的目录路径。
4. 定义下载集合：download_lists变量用于存储下载任务，每个任务由文件的下载链接和保存路径组成。
5. 定义download_list函数：该函数发送HTTP请求获取青少年读本文件列表的JSON数据，然后遍历每个文件项，提取文件的下载链接和保存路径，并将任务添加到download_lists集合中。
6. 定义download函数：该函数接收文件的下载链接和保存路径作为参数，通过requests.get方法下载文件内容，然后保存到指定的输出路径。
7. 主程序入口：在if __name__ == '__main__':中，首先调用download_list函数获取下载任务列表，然后使用ThreadPoolExecutor创建线程池，最大线程数为10。遍历download_lists中的每个任务，使用executor.submit方法提交下载任务给线程池。

这段代码实现了并发下载多个文件的功能，通过多线程的方式加速文件下载过程。需要注意的是，在使用多线程下载时，要注意设置适当的线程数，以避免对目标服务器造成过多的并发请求。同时，也要注意文件保存路径的创建，确保保存文件的目录存在。

import requests
import os
from concurrent.futures import ThreadPoolExecutor
 
# 青少年读本文件列表
url = 'https://s-file-1.ykt.cbern.com.cn/reading/api/zh-CN/14fba334-5e8b-4523-8b60-1f3abde6f60c/elearning_library/v1/libraries/42b4e538-7319-47cb-9d10-12fb58b78420/contents/actions/full/adapter/f848d8b521af3a6c13474ae97d117e7f428208b77884aa2dd46599d81a4ae1a5/files/0.json'
# 下载目录
download_dir = './ebooks'
# 下载集合
download_lists = []
 
 
def download_list():
    response = requests.get(url).json()
    for item in response:
        # 拼接文件访问地址
        file_url = f"https://s-file-1.ykt.cbern.com.cn/reading/api_static/smart_ebooks/{item['unit_id']}.json"
        # 获取文件真实下载链接
        download_url = requests.get(file_url).json()['ebook_third_file']
        # 拼接文件完整保存路径
        output = f"{download_dir}/{item['tags'][0]['title']}/{item['title']}.pdf".replace(' ', '') \
            .replace('：', '·').replace(':', '·').replace("“", "").replace("”", "")
        # 添加到下载集合
        download_lists.append((download_url, output))
 
 
def download(download_url, output):
    # 获取文件目录
    file_download_dir = os.path.dirname(output)
    # 判断目录是否存在，不存在则创建
    if not os.path.exists(file_download_dir):
        os.makedirs(file_download_dir)
    # 下载文件
    resp = requests.get(download_url)
    # 保存文件
    with open(output, 'wb') as f:
        f.write(resp.content)
        print(f"下载完成：{output}")
 
 
if __name__ == '__main__':
    download_list()
    # 多线程下载
    with ThreadPoolExecutor(max_workers=10) as executor:
        for arg in download_lists:
            executor.submit(download, *arg)

这段代码是一个使用Flask创建文件下载服务器的脚本，并在文件右键菜单中添加了“分享此文件”的选项。它能够将指定的文件通过HTTP提供下载，并在本地生成一个随机端口的服务器。

以下是代码的主要功能和流程：

1. 导入所需的模块：导入了Flask、send_from_directory、os、sys、netifaces、random、pyperclip、winreg等模块。
2. 定义启动Flask服务器的函数：start_flask_server函数用于启动Flask服务器。该服务器提供文件下载服务。
3. 获取物理网卡IP：get_wired_ip函数使用netifaces库获取物理网卡的IP地址。
4. 写入注册表项：write_registry_entry函数用于写入注册表项，以添加“分享此文件”的右键菜单选项。
5. 读取注册表值：read_registry_value函数用于读取注册表值，以获取Python的执行路径。
6. 主程序入口：在if __name__ == '__main__':中，首先获取命令行参数和Python可执行路径，然后写入注册表项。
7. 如果没有命令行参数：如果没有传入文件参数，提示用户通过右键菜单运行程序，并等待用户输入回车键退出程序。
8. 如果有命令行参数：如果有传入文件参数，获取文件路径、文件名、物理网卡IP和随机端口。然后在终端打印文件下载地址，并将地址复制到剪贴板。
9. 启动Flask服务器：调用start_flask_server函数启动Flask服务器，提供文件下载服务。

这段代码实现了一个方便的文件分享工具，可以在右键菜单中快速分享指定的文件。用户右键选择文件，点击“分享此文件”，即可在终端获取文件的下载地址，然后可以将下载地址分享给其他人。需要注意的是，此脚本需要在Windows系统上运行。

# -*- coding: utf-8 -*-
 
from flask import Flask, send_from_directory
import os
import sys
import netifaces
import random
import pyperclip
import winreg
 
def start_flask_server(p,fol):
    app = Flask(__name__)
 
    @app.route('/download/<filename>', methods=['GET'])
    def download_file(filename):
        file_path = os.path.join(fol, filename)
        if not os.path.exists(file_path):
            return "文件不存在", 404
        return send_from_directory(fol, filename, as_attachment=True, conditional=True)
          
    app.run(host='0.0.0.0', port=p, debug=False, threaded=True)
 
def get_wired_ip():
    try:
        interfaces = netifaces.interfaces()
        for interface in interfaces:
            addresses = netifaces.ifaddresses(interface)
            if netifaces.AF_INET in addresses:
                for address in addresses[netifaces.AF_INET]:
                    ip_address = address['addr']
                    if ip_address != '127.0.0.1':
                        return ip_address
    except (KeyError, IndexError):
        pass
    return "未找到物理网卡IP"
 
def write_registry_entry(epath, ico):
    reg_path = r"*\shell\Share File"
    key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, reg_path)
    winreg.SetValue(key, None, winreg.REG_SZ, "分享此文件")
    winreg.SetValueEx(key, 'ICON', 0, winreg.REG_SZ, ico)
    winreg.CloseKey(key)
 
    command_path = r"*\shell\Share File\command"
    command_key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, command_path)
    winreg.SetValue(command_key, None, winreg.REG_SZ, epath + ' "%1"')
    winreg.CloseKey(command_key)
 
def read_registry_value():
    try:
        key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"Python.File\Shell\open\command")
        value, _ = winreg.QueryValueEx(key, "")
        winreg.CloseKey(key)
        value = value.split('"')
        return value[1]
    except OSError:
        print("注册表项不存在")
    except Exception as e:
        print(f"读取注册表值时出现错误: {e}")
 
 
if __name__ == '__main__':
    args = sys.argv
    executable_path = os.path.abspath(sys.executable)
    if getattr(sys, 'frozen', False):
        exe = icon = '"' + executable_path + '"'
    else:
        pypath = read_registry_value()
        exe = '"' + pypath + '" "' + args[0] + '"'
        icon = '"' + pypath + '"'
 
    write_registry_entry(exe,icon)
 
    if len(args) - 1==0:
        print("请通过右键菜单运行此程序")
        input("按回车键退出程序")
        sys.exit(0)
    file = args[1]
    path = os.path.dirname(file)
    filename = os.path.basename(file)
    ip = get_wired_ip()
    port = random.randint(10000, 65500)
    url = "http://" + ip + ":" + str(port) + "/download/" + filename
    print("\n↓↓文件下载地址已复制到剪贴板↓↓\n\n " + url + " \n")
    print("↑↑文件下载地址已复制到剪贴板↑↑\n\n\n52pojie\n")
 
    pyperclip.copy(url)
    start_flask_server(port,path)
    

这段代码是一个简单的Python脚本，用于生成和校验软件的注册密钥。脚本使用了wmi库来获取计算机的CPU序列号，并使用hashlib库进行MD5哈希加密。

以下是代码的主要功能和流程：

1. 定义常量和文件路径：

• AUTHOR：作者或标识，用于生成密钥。
• KEYFILENAME：存储密钥的文件名。

1. 获取本地机器的加密字符串：

• 使用wmi库获取计算机的CPU序列号，然后将其与AUTHOR拼接。
• 对拼接后的字符串进行一次MD5哈希加密。
• 将加密结果与AUTHOR再次拼接，进行第二次MD5哈希加密。
• 返回最终的加密字符串。

1. 从文件中获取密钥：

• 打开存储密钥的文件，读取第一行内容作为密钥。
• 返回读取的密钥字符串。

1. 校验是否注册：

• 获取本地机器的加密字符串。
• 从文件中获取密钥。
• 将文件中的密钥与本地机器的加密字符串进行比较。
• 如果比较结果相等，则返回True表示已注册，否则返回False表示未注册。

1. 生成注册密钥文件：

• 获取CPU序列号。
• 将CPU序列号与AUTHOR拼接，并进行一次MD5哈希加密。
• 将加密结果写入存储密钥的文件。

1. 生成注册密钥文件（重载函数）：

• 接受一个解密字符串参数。
• 将解密字符串与AUTHOR拼接，并进行一次MD5哈希加密。
• 将加密结果写入存储密钥的文件。

1. 显示CPU序列号：

• 使用wmi库获取计算机的CPU序列号。

这段代码可以用于生成和验证软件的注册密钥，通过对CPU序列号的加密和校验，实现了简单的注册功能。在使用之前，需要替换AUTHOR为相应的标识，然后根据需要调用相应的函数。

import wmi
import hashlib
import os
 
AUTHOR='52pj'
KEYFILENAME='./RegisterKey.key'
 
#获取CPU的序列号加上Author字段，MD5一次，再在结果加上Author字段再MD5一次，形成最终的比较密码
def GetLocalMachineEncrypedString():
    try:
        c = wmi.WMI()
        decryptString = c.win32_Processor()[0].ProcessorId.strip() + AUTHOR
        encrypedString = hashlib.md5(decryptString.encode('utf-8')).hexdigest()
        decryptString = encrypedString + AUTHOR
        encrypedString = hashlib.md5(decryptString.encode('utf-8')).hexdigest()
    except:
        encrypedString = hashlib.md5(AUTHOR.encode('utf-8')).hexdigest()
    return encrypedString
 
#文件中储存的Key是CPU序列号加Author，一次MD5结果
def GetKeyFromFile():
    try:
        f=open(KEYFILENAME,'r')
        lines=f.readlines()
        keyString=lines[0]
        return keyString
    except:
        return ''
 
#把文件的key加上author，做最后一次MD5生成最终结果
def CheckIsRegistered():
    decryptString=GetKeyFromFile()+AUTHOR
    encrypedString = hashlib.md5(decryptString.encode('utf-8')).hexdigest()
    if encrypedString==GetLocalMachineEncrypedString():
        return True
    else:
        return False
 
#生成key文件
def BuildRegisterKey():
    try:
        c = wmi.WMI()
        decryptString = c.win32_Processor()[0].ProcessorId.strip() + AUTHOR
        encrypedString = hashlib.md5(decryptString.encode('utf-8')).hexdigest()
    except:
        encrypedString=''
 
    try:
        f=os.open(KEYFILENAME,os.O_CREAT|os.O_WRONLY)
        os.write(f,encrypedString.encode('utf-8'))
        print('写入', KEYFILENAME, '成功')
    except:
        print('写入',KEYFILENAME,'失败')
 
def BuildRegisterKey(decryptString):
    if decryptString:
        decryptString = decryptString + AUTHOR
        encrypedString = hashlib.md5(decryptString.encode('utf-8')).hexdigest()
    else:
        encrypedString=''
 
    try:
        f=os.open(KEYFILENAME,os.O_CREAT|os.O_WRONLY)
        os.write(f,encrypedString.encode('utf-8'))
        print('写入', KEYFILENAME, '成功')
    except:
        print('写入',KEYFILENAME,'失败')
 
def ShowCPUSerialNumber():
    try:
        c = wmi.WMI()
        decryptString = c.win32_Processor()[0].ProcessorId.strip()
    except:
        decryptString=''
    return decryptString

这段代码是一个Python脚本，用于从CNN新闻网站抓取新闻链接，然后使用OpenAI的GPT-3.5模型生成摘要并将其保存到文本文件中。代码使用了 requests 库来发送HTTP请求，BeautifulSoup 来解析HTML内容，以及OpenAI的API来生成摘要。

以下是代码的主要功能和流程：

1. 导入所需的模块：

• os：用于操作文件系统路径。
• datetime：用于获取当前日期。
• requests：用于发送HTTP请求和获取网页内容。
• BeautifulSoup：用于解析HTML页面内容。
• urljoin：用于构建绝对URL。
• openai：用于访问OpenAI的API。
• time：用于控制请求频率。

1. 设置OpenAI的API密钥：

• 在代码中设置OpenAI的API密钥。

1. 获取当前日期并创建文件夹：

• 使用datetime.date.today()获取当前日期。
• 构建文件夹路径，并使用os.makedirs创建文件夹。

1. 构建文件路径和初始URL：

• 构建要保存文件的路径。
• 设置CNN新闻网站的初始URL。

1. 发送请求并解析HTML内容：

• 使用requests.get获取CNN新闻网站的HTML内容。
• 使用BeautifulSoup解析HTML内容，找到新闻链接的容器。

1. 遍历链接并生成摘要：

• 遍历获取到的新闻链接。
• 对每个链接，发送HTTP请求，获取文章内容并解析HTML。
• 提取文章内容，构建用户输入，然后使用OpenAI的ChatCompletion生成摘要。

1. 控制请求频率：

• 使用time.sleep控制每个请求的时间间隔，以控制请求频率。

1. 将摘要写入文件并打印：

• 将生成的摘要写入文本文件。
• 打印生成的摘要。

运行脚本前，确保已安装了需要的库（requests、BeautifulSoup、openai），并替换API密钥。另外，注意不要过度访问网站或OpenAI API，以遵守相关的使用条款和规定。

import os
import datetime
import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin
import openai
import time
 
# 在这里设置你的 OpenAI API 密钥
openai.api_key = ''
 
# 获取当前日期
current_date = datetime.date.today()
 
# 创建文件夹路径
folder_path = os.path.join("C:/桌面/每日新闻", str(current_date))
 
# 创建文件夹
os.makedirs(folder_path, exist_ok=True)
 
# 创建文件路径
file_path = os.path.join(folder_path, "CNN新闻.txt")
 
url = "https://edition.cnn.com/"
 
response = requests.get(url)
html_content = response.content
 
soup = BeautifulSoup(html_content, "html.parser")
 
container = soup.find(class_="container__field-links container_ribbon__field-links")
 
if container:
    links = container.find_all("a")
 
    # 打开文件并写入内容
    with open(file_path, "w", encoding="utf-8") as file:
        # 遍历链接并访问每个链接
        for link in links:
            href = link.get("href")
            full_link = urljoin(url, href)
 
            try:
                response = requests.get(full_link)
                response.raise_for_status()  # 检查是否有异常状态码
                html = BeautifulSoup(response.content, "html.parser")
 
                articles = html.find_all(class_="article__content")
 
                if articles is None:
                    continue
 
                content = ' '.join([article.get_text() for article in articles])
 
                user_input = f"摘要以下文章内容：\n{content}\n摘要："
 
                # 控制请求频率
                time_between_requests = 60 / 3  # 3 RPM
                time.sleep(time_between_requests)
 
                summary_response = openai.ChatCompletion.create(
                    model="gpt-3.5-turbo",
                    messages=[
                        {"role": "system", "content": "You are a helpful assistant."},
                        {"role": "user", "content": user_input}
                    ],
                    temperature=1,
                    max_tokens=256,
                )
 
                summary = summary_response.choices[0].message['content'].strip()
 
                # 将摘要写入文件
                file.write(summary + "\n\n")
 
                # 打印摘要
                print(summary)
                print('---------------------------------------------------------------------------------')
 
            except requests.RequestException as e:
                print(f"请求出错：{str(e)}")
 
    print("文件写入完成！")

这段代码是一个简单的爬虫脚本，用于从小说阅读网站上抓取小说的章节内容。脚本使用了 requests 库来发送HTTP请求，使用 BeautifulSoup 来解析HTML内容，以及使用正则表达式来匹配章节目录。

以下是代码的主要功能和流程：

1. 导入所需的模块：

• requests：用于发送HTTP请求和获取网页内容。
• re：用于正则表达式匹配。
• BeautifulSoup：用于解析HTML页面内容。

1. 定义 get_soup 函数：

• 通过给定的URL和参数，发送GET请求并获取网页内容。
• 使用 BeautifulSoup 解析网页内容，并返回解析后的BeautifulSoup对象。

1. 定义 get_chapter_content 函数：

• 通过给定的章节URL，获取章节内容。
• 使用正则表达式匹配章节内容，并去除不需要的部分。
• 返回章节内容。

1. 定义 main 函数：

• 定义一个小说名字列表 namelist。
• 遍历小说名字列表，对每本小说进行爬取。
• 通过小说名字搜索小说链接，获取小说章节目录。
• 对每个章节链接，循环尝试获取章节内容，并保存到对应的文本文件。

此脚本通过爬取小说阅读网站，根据小说名字搜索小说链接，获取小说章节目录，然后逐个爬取章节内容并保存到对应的文本文件中。运行脚本前，请确保已安装了 requests、BeautifulSoup 和 re 库。另外，请注意网站的使用条款和规定，避免过度访问和爬取。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# time: 2023/7/25 15:22
# file: xbiquge.py
# author: lyx
 
import requests
import re
from bs4 import BeautifulSoup
 
def get_soup(url, params=None):
    res = requests.get(url=url, params=params)
    res.encoding = 'utf-8'
    return BeautifulSoup(res.text, 'html.parser')
 
def get_chapter_content(url):
    chapter = requests.get(url)
    chapter.encoding = 'utf-8'
    chapter1 = BeautifulSoup(chapter.text, 'html.parser')
    chapter_div = chapter1.find('div', {'id': 'content'})
    if chapter_div:
        paragraphs = chapter_div.find_all('p')
        for p in paragraphs:
            p.decompose()
        div = chapter_div.find_all('div')
        for d in div:
            d.decompose()
    return chapter_div
 
def main():
    namelist = ['阵问长生','神明模拟器','半岛检查官','全民逃荒，我的物品能升级','玄鉴仙族']
    for bookname in namelist:
        print(f"爬取书籍： {bookname}!")
        url = 'https://www.ibiquges.info/modules/article/waps.php'
        data = {'searchkey': bookname}
        soup = get_soup(url, data)
        content = soup.find('a', string=bookname)
 
        if content:
            url1 = 'https://www.ibiquges.info'
            url = content['href']
            content = get_soup(url)
            catalog1 = content.find('div', id='list')
            catalog2 = str(catalog1)
            pattern = r'<dd><a href="(.*?)">(.*?)</a></dd>'
            matches = re.findall(pattern, catalog2)
            result = [(match[0], match[1]) for match in matches]
            with open(bookname + '.txt', 'a', encoding='utf-8') as file:
                for chapter_url, chapter_title in result:
                    for _ in range(20):
                        url2 = url1 + str(chapter_url)
                        chapter_div = get_chapter_content(url2)
                        if chapter_div is not None:
                            middle_text = chapter_div.get_text("\n", strip=True)
                            print('\n\n\n' + chapter_title + '\n\n\n')
                            file.write('\n\n\n' + chapter_title + '\n\n\n')
                            file.write(middle_text)
                            break
                        else:
                            continue
        else:
            print("未找到匹配的URL")
 
if __name__ == "__main__":
    main()