Python on 苏三有春的博客

如何在Windows中使用opuslib库

Fri, 07 Nov 2025 20:09:00 +0800

前言

Hi,everyone，本周笔者在Windows环境下使用python开发上位机时，意外发现需要解码opus音频数据，因此笔者需要在上位机中加入opus的编解码器，在opus官网下载的解码器需要在Linux环境下运行，编译出来是一个ELF文件，而笔者的上位机是基于python开发的，且目标用户都使用Windows环境，因此笔者理所当然地就要解决如何在Windows环境下使用python开发opus编解码器这个问题，笔者使用opuslib + opus.dll的形式解决问题，笔者会提供笔者使用的opus.dll下载链接和配置方式。

你是否需要opuslib

opuslib是一个为libopus音频编码库提供Python绑定的工具包，能够让使用者在Python项目中使用Opus音频编解码器。其核心价值就在于，它将Opus编解码器的强大功能以易于使用的Python接口形式提供出来。很重要的一点是：在opuslib中，无论是将PCM音频流数据编码成Opus数据，还是将Opus数据解码成PCM音频流进行播放，其Opus数据包是裸的，即纯粹的Opus数据，为何要强调这一点？因为有些opus编解码，例如ffmpeg是会在Opus数据外套一层ogg格式，而如果读者正是想要该封装格式的可以使用ffmpeg来编码或解码数据。

所以：

你需要使用python来程序来编解码opus音频数据
你需要在Windows环境下使用
你想要解码或编码纯粹的opus数据，而不是被ogg（或其它）封装后的数据

那么这篇文章可以帮到你，文章不长，可以读读。

下载opuslib

在你的python虚拟环境下使用命令下载opuslib库:

1

pip install opuslib

此命令会在你当前使用的python虚拟环境下安装opuslib库，但请注意，此时如果你尝试使用导入该库并使用，会报错。

opuslib使用异常

例如：

1
2
3


import opuslib # 导入opuslib库

decoder = opuslib.Decoder(48000, 960) # 初始化解码器

从报错信息中可以看到，当你初始化一个opus解码器对象时，会抛出异常，异常信息显示Could not find Opus library. Make sure it is installed.，索引到最后报错的文件可以看到：

可以看到，当没有在lib_location这个变量没有找到库时，就会抛出该异常，提示你它并没有找到相应的opus库。你可以将opuslib理解为一个封装，它本质上没有opus编解码器，而是调用写好的opus编解码器，转换成python形式的接口，方便你在python中调用，因此我们需要手动添加一个可以在Windows环境下运行的opus库进去。

顺便提一嘴：这个__init__.py文件是在虚拟环境\Lib\site-packages\opuslib\api\__init__.py，虚拟环境是你的虚拟环境名称，笔者这里叫做venv，因此笔者这里的完整路径是:D:\HugoBlog\dev\content\post\useOpuslibInWindows\testopuslib\.venv\lib\site-packages\opuslib\api\__init__.py要提这一嘴是因为在python中__init__.py文件特别多，与api同级下还有个__init__.py，别弄混了。

下载opus.dll

笔者找到了一个可以在Windows下运行的opus动态库（opus.dll），将其放在CSDN资源和百度网盘中，附上链接，大家可以随意下载使用。

【免费】Windows下使用的opus编解码动态库资源-CSDN下载

百度网盘分享-opus.dll提取码: 7aed

配置opus动态库

还记得上面笔者提到的__init__.py文件中的lib_location变量吗，该变量实质上是一个地址，你当然可以使用绝对地址的形式将opus.dll的位置直接写入lib_location，如下所示：

但考虑代码健壮性，也可以这么写：

1
2
3
4
5
6


lib_location = find_library('opus')
current_dir = os.path.dirname(os.path.abspath(__file__)) # 获取当前文件所在目录
lib_location = os.path.join(current_dir, 'opus.dll') # 构建 opus.dll 的完整路径（在同一目录下）
if lib_location is None:
 raise Exception(
 'Could not find Opus library. Make sure it is installed.')

这段代码的作用是：

current_dir：获取当前文件的目录，即：__init__.py的目录
lib_location：将current_dir与opus.dll拼接在一起

使用这段代码，读者仅需将opus.dll放在与__init__.py同一目录下即可，如上图所示。

小结

读到这里，读者们应该可以自行使用opuslib来编写opus音频编解码库了，我们来做个小结：

使用pip包管理器下载opuslib，但opuslib无法在Windows中直接使用
下载opus.dll动态库
将opus.dll的地址赋值给opuslib库中的初始化函数，笔者提供相对地址与绝对地址两种方式

那么接下来，笔者再提供一些笔者在编写语音编解码器时踩过的一些坑

pyinstaller无法打包第三方库

笔者目的是使用pyqt做一个上位机，可视化地展示语音解码的波形与播放。关于如何使用pyqt做一个语音播放器，可以看笔者下面这几篇文章

PyAudio库基本知识详解

基于PyQt开发的脚本集合包（十三）

基于PyQt开发的脚本集合包（十四）

在使用pyqt做完了语音播放器后，使用pyinstaller工具，将程序打包成.exe可执行文件，在运行时报错：

这个报错显示exe文件在运行时没有找到一个名为opuslib的库，由于我是用pyinstaller的时候并没有将所有东西压缩成一个单独的exe文件，pyinstaller会将我导入的一些第三方库比如PyQt5、numpy、matplotlib等放在一个名为_internal的目录下，检查该目录发现，并没有opuslib，这个_internal目录与你在编程时的虚拟环境目录很像，存放了你使用pip下载的第三方库。

因此，这里可能是pyinstaller出于某种原因，并没有将虚拟环境目录下的opuslib一起打包进来，笔者在网上找了许多方法，都比较复杂，笔者在这里提供一个简单的，直接将你使用的opuslib库拖到_internal目录下即可。

这样就能解决No module named 'opuslib'的问题。

Opus解码器样例

这里笔者给出一个opus的解码器样例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


import opuslib

class OpusDecoder:
 def __init__(self):
 # 配置参数
 SAMPLE_RATE = 48000 # Opus 标准采样率（支持 8000, 12000, 16000, 24000, 48000）
 CHANNELS = 1 # 声道数（1=单声道，2=立体声）
 FRAME_SIZE_MS = 20 # 每帧时长（毫秒，Opus 常用 20ms 的帧）

 # 计算每帧的样本数（如 48000Hz * 20ms = 960 样本/帧）
 self.FRAME_SIZE = int(SAMPLE_RATE * FRAME_SIZE_MS / 1000)
 # 初始化 Opus 解码器
 self.decoder = opuslib.Decoder(SAMPLE_RATE, CHANNELS)
 pass
 def decode_opus_to_pcm(self,opusfile,pcmfile):
 self.INPUT_OPUS_FILE = opusfile
 self.OUTPUT_PCM_FILE = pcmfile
 # 打开文件并解码
 with open(self.INPUT_OPUS_FILE, "rb") as opus_file, open(self.OUTPUT_PCM_FILE, "wb") as pcm_file:
 while True:
 # 读取 Opus 帧（注意：这里假设文件是裸 Opus 流，无 Ogg 封装）
 opus_frame = opus_file.read(40) # 40 是经验值，需根据实际帧大小调整

 # 无更多数据时退出循环
 if not opus_frame:
 break

 # 解码为 PCM
 pcm_data = self.decoder.decode(opus_frame, self.FRAME_SIZE)

 # 写入 PCM 文件
 pcm_file.write(pcm_data)

 # print("解码完成！输出文件:", self.OUTPUT_PCM_FILE)
 # return self.OUTPUT_PCM_FILE
# 测试样例
OpusDecoder().decode_opus_to_pcm("input.opus","output.pcm")

输入input.opus的opus数据（裸的opus数据，二进制文件），即可解码得到output.pcm音频流数据(裸的pcm数据，二进制文件，可直接在adobe之类的软件播放)

好啦，如果本文有一点点帮助你，那荣幸之至，后续笔者也会考虑出一文解释一下opus的数据，其实从opus的数据包中可以逆推出一些信息，如果想看的话点赞留言催更，笔者会尽快出文，祝你变得更强！

基于PyQt开发的脚本集合包（十四）

Fri, 20 Dec 2024 17:28:00 +0800

前言

在我们上两个功能模块中，音频编解码模块与音频播放模块，都在操作音频数据，在音频数据解码后生成的pcm数据以文本格式保存，无法直接给音频播放模块播放，因此在本文中，我们将实现pcm二进制文件生成模块，将pcm数据文本转换成.pcm格式的二进制文件

UI布局展示

非常简单，仅一个文件选择区以及一个处理按钮，选择相应的pcm数据文本，开始执行即可转换为.pcm格式二进制文件

代码展示

PcmBUilderClass.py

下面给出UI界面代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtSvg import *

from component.btnStyle import *
from component.editStyle import *
from component.getPath import *
from tools.pcmBuilder import *

class WPcmBuilder(QWidget):
 def __init__(self):
 super().__init__()
 self.filePaths = ['']
 self.initUI()

 def initUI(self):
 self.pcmBuildlayout = QVBoxLayout()
 self.setLayout(self.pcmBuildlayout)
 # 文件选择
 self.filelayout = QHBoxLayout()
 self.lable = QLabel("请选择文件",self)
 self.filelayout.addWidget(self.lable)
 self.input = QLineEdit(self)
 LineEditStyle(self.input)
 self.filelayout.addWidget(self.input)
 self.choosebtn = QPushButton("选择文件",self)
 btnReleaseStyleA(self.choosebtn)
 self.choosebtn.clicked.connect(self.getpath)
 self.filelayout.addWidget(self.choosebtn)
 self.pcmBuildlayout.addLayout(self.filelayout)

 # 开始处理
 self.exebtn = QPushButton("开始处理",self)
 btnReleaseStyleA(self.exebtn)
 self.exebtn.clicked.connect(self.exebtn_press_clicked)
 self.pcmBuildlayout.addWidget(self.exebtn)



 def getpath(self):
 get_path(self)
 self.input.setText(self.filePaths[0])

 def exebtn_press_clicked(self):
 pcmBuilder(self.filePaths[0])

pcmBuilder.py

下面给出pcm格式转换脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import struct

def pcmBuilder(filepath):
 samples = []
 with open(filepath, 'r') as file:
 lines = file.readlines()
 for line in lines:
 samples = samples + [int(data.strip(),16) - 0x10000 if int(data.strip(),16) >= 0x8000 else int(data.strip(),16) for data in line.split()]
 # print(samples)

 with open('workspaces/output.pcm', 'wb') as pcm_file:
 for sample in samples:
 pcm_file.write(struct.pack('<h', sample))
 print("转换完成，输出文件为 output.pcm")

这里我们解释一下：

int(data.strip(),16) - 0x10000 if int(data.strip(),16) >= 0x8000 else int(data.strip(),16) for data in line.split()

这行代码的作用是处理一行十六进制数据，并根据一定的条件将其转换为整数列表。下面我将逐步解析代码。

line.split(): 这将字符串 line 按照空格（包括空格、制表符、换行符等）分割成一个字符串列表，每个元素代表一个十六进制数字。
data.strip(): 这会去掉每个 data 子字符串的前后空白字符。
int(data.strip(), 16): 这会将处理过的 data 字符串从十六进制（基数 16）转换成整数。例如，'FF' 会转换为 255，'8000' 会转换为 32768。
条件逻辑:
- if int(data.strip(), 16) >= 0x8000: 这检查该十六进制数（转换成整数后）是否大于等于0x8000（即 32768 十进制）。
  - 如果是，则会减去 0x10000（即 65536 十进制）。这通常用于将 16 位无符号数转换为有符号数，表示范围从 -32768 到 32767（假设是 16 位二进制补码格式）。
  - 如果否，则直接使用该整数值。
samples = samples + [...]: 这表示将处理后的结果（即这行数据的整数列表）添加到现有的 samples 列表中。

示例

假设 line 是如下的内容：

1

pythonCopy Codeline = "7FFF 8000 0001"

逐步处理

第一个元素：'7FFF'
- data.strip() -> '7FFF'
- int('7FFF', 16) -> 32767（十进制）
- 因为 32767 < 32768，没有修改，保持 32767。
第二个元素：'8000'
- data.strip() -> '8000'
- int('8000', 16) -> 32768（十进制）
- 因为32768 >= 32768，需要减去0x10000（65536）：
  - 32768 - 65536 -> -32768。
第三个元素：'0001'
- data.strip() -> '0001'
- int('0001', 16) -> 1（十进制）
- 因为 1 < 32768，保持 1。

最终列表

经过处理后，samples 列表将会是：

1

samples = [32767, -32768, 1]

这段代码的作用是读取十六进制数字，并根据需要将其转换为有符号的 16 位整数（如果需要的话）。如果十六进制数大于或等于 0x8000，它会被视为一个负数（通过二进制补码表示）。然后，这些处理后的数字会被添加到 samples 列表中。

基于PyQt开发的脚本集合包（十三）

Fri, 20 Dec 2024 13:03:00 +0800

前言

通过上一篇文章，我们已经大概了解了PyAudio是一个什么样的库以及给出了相应的示例代码，那么在本文中，我们就要使用PyAudio库，来实现音频的播放，同时呢我们将加上matplotlib库，来绘制音频的波形。通过阅读本文，你将了解到：如何使用PyAudio，将音频文件传入PyAudio，如何绘制音频波形，以及音频波形与音频播放的同步，如何避免音频卡顿问题。

播放器思想

首先，我们要通过PyAudio来实现音频的播放功能，通过读取PCM文件，将音频输出给外设（耳机，扬声器等）。
此外，在音频输出的过程中，同时绘制当前读取数据块的折线图。
在当前数据块被读取时，折线图将绘制完成，当数据块被读取完时，数据块所表示的音频将被播放完。
将下一数据块的音频数据读取，然后重复上面的操作
__init__：在对象初始化时，将一些PyAudio的参数初始化完成，比如采样率，声道，采样点大小，数据块大小等。并创建画布
play：播放方法，关闭上一个音频流，如果有的话，打开音频流，开一个线程来执行播放与绘画
load_pcm_audio：从pcm文件中读取数据
play_audio：在音频流中写入数据块，并重新绘制折线图
update_parameters：更新播放器的参数，如采样率，声道等
closeEvent：关闭音频流，释放系统资源

代码展示

下面是音频播放器的代码，而非播放器UI的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112


from random import sample
import sys
import numpy as np
import pyaudio
import matplotlib.pyplot as plt
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QFileDialog
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
import threading


class AudioPlayer(QWidget):
 def __init__(self,QWidget):
 super().__init__()

 self.file = ''

 self.layout = QVBoxLayout()
 self.setLayout(self.layout)


 self.figure = plt.Figure()
 self.canvas = FigureCanvas(self.figure)
 self.layout.addWidget(self.canvas)

 # 初始化PyAudio
 self.p = pyaudio.PyAudio()

 # 设置播放参数
 self.sample_rate = 16000 # 采样率
 self.channels = 1 # 单声道
 self.sample_width = 2 # 16位深度
 self.chunk_size = 1024 # 每次播放的PCM数据块大小

 # 波形更新
 self.x_data = np.arange(self.chunk_size)
 self.y_data = np.zeros(self.chunk_size)
 self.plot = self.figure.add_subplot(111)
 self.line, = self.plot.plot(self.x_data, self.y_data)

 # 去掉坐标轴
 self.plot.axis('off')

 # 显式设置坐标轴范围，确保波形线延伸到整个画布
 self.plot.set_xlim(0, self.chunk_size) # 设置x轴范围为数据块大小
 self.plot.set_ylim(-1, 1) # 设置y轴范围为[-1, 1]，16-bit PCM数据的常规范围

 self.audio_data = None
 self.index = 0
 self.stream = None

 def play(self,filename):
 if self.file != filename:
 self.file = filename
 self.load_pcm_audio(filename)
 self.index = 0 # 重置播放进度
 # 如果audio_data为空，或者没有选择音频，直接返回
 if self.audio_data is None:
 print("请先选择一个音频文件！")
 return

 # 每次播放前重置播放进度和音频流
 self.index = 0

 # 如果stream已经存在且正在播放，先停止它
 if self.stream is not None and self.stream.is_active():
 self.stream.stop_stream()
 self.stream.close()

 # 打开音频流
 if self.sample_width == 2:
 samplewith = pyaudio.paInt16
 elif self.sample_width == 4:
 samplewith = pyaudio.paInt32
 self.stream = self.p.open(format=samplewith,
 channels=self.channels,
 rate=self.sample_rate,
 output=True,
 frames_per_buffer=self.chunk_size)

 # 启动一个单独的线程来播放音频
 threading.Thread(target=self.play_audio, daemon=True).start()

 def load_pcm_audio(self, filename):
 # 读取PCM音频文件
 with open(filename, 'rb') as f:
 self.audio_data = np.frombuffer(f.read(), dtype=np.int16)

 def play_audio(self):
 while self.index < len(self.audio_data):
 chunk = self.audio_data[self.index:self.index + self.chunk_size]
 if len(chunk) < self.chunk_size and len(chunk) > 0:
 chunk = np.pad(chunk, (0, self.chunk_size - len(chunk)), 'constant')
 self.index += self.chunk_size
 self.stream.write(chunk.tobytes())

 # 更新波形数据
 self.y_data = chunk / 32768.0 # 16-bit PCM音频数据范围 [-1, 1]
 self.line.set_ydata(self.y_data)
 self.canvas.draw()

 def update_parameters(self, sample_rate, channels, sample_width):
 self.sample_rate = sample_rate
 self.channels = channels
 self.sample_width = sample_width

 def closeEvent(self, event):
 if self.stream is not None:
 self.stream.stop_stream()
 self.stream.close()

 self.p.terminate()
 event.accept()

下面给出代码的详细解释：

_init_

创建画布，绘制图像，并将画布加入到layout中
初始化PyAudio
设置播放参数，默认16K采样率，单声道，16比特采样点，数据块大小为1024
初始化坐标轴，在画布中，X轴不变，Y会随着数据块的更新而变化，每次更新折线图便会发生一次改变
去掉坐标轴（美观）
X轴的范围是[0,1024]，即一个数据块的大小，Y轴的范围是[-1,1]，这是16bit PCM数据的常规范围
初始化音频数据变量，索引值，音频流等

play

如果当前的文件与重新选择的文件不一致，则会重新加载音频文件，如果没有音频文件，则会返回错误
重置播放进度
如果当前有音频流存在，暂停并结束它
重新打开音频流
单独开一个线程来执行播放音频和绘制波形

load_pcm_audio

从文件中读取数据，我们来详细解释一下self.audio_data = np.frombuffer(f.read(), dtype=npint16)

f.read()

f 是一个文件对象，通常是通过 open 打开文件后得到的。
f.read()读取文件内容，并将其作为一个字节串（bytes）返回。
- 如果文件是二进制文件（比如 .wav 或 .mp3 格式的音频文件），f.read() 会读取文件的所有字节内容。
- f.read() 返回的数据是一个包含音频原始二进制数据的字节序列。

np.frombuffer()

np.frombuffer() 是 NumPy 提供的一个函数，用于从缓冲区（字节串、字节流等）中创建一个 NumPy 数组。
它将原始的二进制数据解释为指定数据类型的数组。
该函数通常用于将文件中的二进制数据（如音频文件）转换为 NumPy 数组，方便进一步处理。

dtype=np.int16

dtype参数指定了生成的NumPy数组的数据类型。在这里，dtype=np.int16表示将字节数据转换为 16 位整数（int16）。
- np.int16 表示每个数据元素是一个 16 位有符号整数（即每个值占 2 个字节）。
- 16 位整数常用于表示音频数据，因为音频信号通常是通过这种方式存储的，特别是当音频使用 PCM（脉冲编码调制）格式时。

self.audio_data

这段代码将np.frombuffer()返回的NumPy数组赋值给self.audio_data。self.audio_data用于存储读取的音频数据。
- 该数组的元素是从音频文件中读取的 PCM 数据，每个元素是一个 16 位整数，表示音频样本的幅度值。

play_audio

判断index当前音频的进度，如果还没读取完数据，则将audio_data中的数据分块传给chunk
如果chunk的长度小于1024，说明audio_data已经到了最后一个数据块，且大小不等于1024，因此需要在chunk后面补零
更新index音频播放进度
将chunk数据块的数据写入音频流中
将chunk数据缩放到[-1,1]中
绘制折线图

这里值得注意的是，为什么当chunk不足1024时，需要啊在chunk后面补零呢，是画布的X轴大小为1024，如果Y轴的数据没有1024个，则无法完成绘画

update_parameters

更新参数方法，供上层UI界面调用

closeEvent

关闭音频流且释放系统资源

值得注意的是，closeEvent方法通常是在窗口关闭事件发生时自动被调用的，它是与窗口或界面关闭相关联的事件处理函数。

event.accept方法是用来标记事件已被处理，表示允许窗口关闭（即立即销毁窗口并退出程序）。如果你不调用event.accept窗口，窗口的关闭可能会被组织或无效。

音频波形与音频播放的同步

如果要实现音频的可视化，音频播放与波形绘制的同步时必不可少的操作，在这里，我们通过PyAudio的流式操作，将音频数据分成数据块来读取并播放，这样的操作思想为实现波形绘制与音频播放的同步奠定了基础。

在每一个音频数据块被读取时，我们将数据块交给PyAudio播放的同时，也制作数据进行波形绘制。这样确保了绘制与播放操作的是一个数据块，不会出现速度不一的情况。

主要的实现在play_audio方法中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 def play_audio(self):
 while self.index < len(self.audio_data):
 chunk = self.audio_data[self.index:self.index + self.chunk_size]
 if len(chunk) < self.chunk_size and len(chunk) > 0:
 chunk = np.pad(chunk, (0, self.chunk_size - len(chunk)), 'constant')
 self.index += self.chunk_size
 self.stream.write(chunk.tobytes())

 # 更新波形数据
 self.y_data = chunk / 32768.0 # 16-bit PCM音频数据范围 [-1, 1]
 self.line.set_ydata(self.y_data)
 self.canvas.draw()

如何避免音频卡顿

在笔者第一次使用PyAudio的功能时，为了实现播放功能，而没有深入了解PyAudio的运行原理，导致在第一次播放时正常，再重复播放几次后会出现卡顿情况，播放次数越多卡顿越厉害，到最后，音频的波形只有几帧了，随后笔者开始对如何实现PyAudio展开了优化，上面是优化后的代码，下面给出优化的心路历程。

UI线程与音频线程的阻塞问题

音频播放是一个需要实时更新的过程，可能会造成UI线程和音频线程的冲突。特别是音频播放涉及IO操作，如果UI更新阻塞了音频播放，可能会导致卡顿。

修改后，通过开子线程的方式，将UI线程与音频线程区分开，使音频播放独立于UI线程执行。

内存管理问题

在之前的代码中，每一次点击播放，都会重新调用一次load_pcm_audio，会重新将整个PCM文件保存在self.audio_data中，如果文件较大，这会消耗大量的内存，尤其是当多次播放时，音频数据会反复加载，可能会导致内存积累，引起卡顿。

修改后，仅有当检测读取文件与上一次读取文件不一致时，才会调用load_pcm_audio，否则将不重新加载PCM文件，直接使用已有数据，使用self.index来控制播放进度。

PyAudio流的管理问题

在之前的代码中，初始化self.p = pyaudio.PyAudio()是放在play方法中，这会导致，每次按键调用play方法时，stream对象就会被重复创建且播放时没有正确地停止和清理，导致音频流的资源没有得到释放，影响性能。

修改后，stream对象在初始化时便被创建，往后在play方法时不重复创建，在结束时被释放。

PyAudio库基本知识详解

Thu, 19 Dec 2024 20:03:00 +0800

前言

结合前段时间我们做的音频编解码器，这样我们就可以将获取到的ADPCM数据，转换成PCM数据，然后播放出来，得到一个完整的音频数据，因此，接下来几篇文章中，我们想做一个播放PCM格式的音频播放器。待到音频编解码器完成，播放器完成，或许我们就能做一个语音识别功能模块，通过一个小收音器的BLE蓝牙连接，连接到电脑上，实时完成音频传输，解码，以及识别的整套流程。可以完成语音写入文本，不仅彻底解放双手，还能解放双脚，让你离开电脑桌也能输入文本（不过也是作者的美好幻想，先挖个坑，距离实现遥遥无期，尽请期待！）

在此之前呢，我们先脚踏实地的，了解一下我们必要的第三方库，PyAudio。

前置知识

在介绍PyAudio库之前我们需要先了解一点点前置内容

采样率：采样率是指机器每秒采样的次数，是音频处理中的重要参数。如：采样率为44100，即1秒钟采样44100次，常见的采样率为44100、48000，在小型设备中，如只专注语音的识别，不在乎音质，通常会选用更小的采样率，如8000、16000等，换取硬件设备的成本优势
音频格式：指的是每个采样点的长度，如：paInt16，表示每个采样点为16比特，一次采样获取的数据为16比特，常见的采样点大小为8、16、32等。单位为比特。通常采样率与采样点大小即可确定一定时间内，采样获取的数据大小，如：当音频格式为paInt16，采样率为8KHz，那么1s中，将采样到 8000 * 16bit = 128kb的数据。
通道：指的是声道，麦克风拾音的过程。分为单声道，多声道，立体声，联合立体声等。
块：块是指数据块，在PyAudio可以实时处理动态音频数据，也就是音频流，而处理音频流实际上也是将连续的（实际上并非连续）输入以数据块的形式处理，并不是来一个字节处理一个字节，可以理解为缓冲区buffer的概念。

稍稍理解这些概念，以便后续阅读中看懂PyAudio的参数，如果没懂，可以返回来反复阅读。

PyAudio

PyAudio 是一个用于在 Python 中进行音频处理的库，它为我们提供了跨平台的接口，用于录音、播放和处理音频流。PyAudio 封装了 PortAudio 库，PortAudio 是一个跨平台的音频库，支持多种操作系统（如 Windows、macOS、Linux）。

PyAudio的常见用途

录音（Recording Audio）：可以从麦克风获取音频数据。
播放音频（Playing Audio）：可以播放 WAV 或其他格式的音频文件。
实时音频处理：处理音频数据流（例如，分析麦克风输入，实时音效等）。

安装 PyAudio

首先需要安装 PyAudio。可以使用 pip 来安装：

1

pip install pyaudio

PyAudio的核心概念

流（Stream）： PyAudio 的核心概念是“流”（Stream）。流是数据的一个持续流动的通道，用于音频输入或输出。你可以创建一个输入流（录音）或输出流（播放音频），然后使用流来传输音频数据。
音频格式和数据： PyAudio 支持多种音频格式，例如 paInt16（16 位整数格式）和 paFloat32（32 位浮点格式）。音频数据通常是原始的字节流数据，可以通过 NumPy 数组或其他方式进行处理。
回调函数：在实时音频流的场景中，通常使用回调函数来处理音频数据。回调函数会在每次采集到一块音频数据时被调用。

主要功能

录音示例：以下是一个使用 PyAudio 录音的简单示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


import pyaudio
import wave

# 设置录音参数
FORMAT = pyaudio.paInt16 # 音频格式
CHANNELS = 1 # 单声道
RATE = 44100 # 采样率
CHUNK = 1024 # 每次读取的数据块大小
RECORD_SECONDS = 5 # 录音时长
OUTPUT_FILENAME = "output.wav" # 输出文件

p = pyaudio.PyAudio()

# 开启输入流
stream = p.open(format=FORMAT,
 channels=CHANNELS,
 rate=RATE,
 input=True,
 frames_per_buffer=CHUNK)

print("开始录音...")

frames = []

# 录制数据
for _ in range(0, int(RATE * RECORD_SECONDS / CHUNK)):
 data = stream.read(CHUNK)
 frames.append(data)

print("录音结束...")

# 停止流并关闭
stream.stop_stream()
stream.close()
p.terminate()

# 将录音保存为WAV文件
wf = wave.open(OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()

这里有值得一提的一个点：
1
2
3
4
# 录制数据
for _ in range(0, int(RATE * RECORD_SECONDS / CHUNK)):
 data = stream.read(CHUNK)
 frames.append(data)
这个循环的主要目的是从流中读取数据，并添加到frams列表中，可以看到RATE * RECORD_SECONDS为采样率 * 录音时长，这可以得到在本次录音中一共采样的次数，/ CHUNK表明采样的数据被分块读取并写入frames。这里其实隐式的处理了采样格式，即paInt16。

播放音频示例：以下是一个播放 WAV 文件的简单示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import pyaudio
import wave

# 打开WAV文件
wf = wave.open('output.wav', 'rb')

p = pyaudio.PyAudio()

# 打开输出流
stream = p.open(format=pyaudio.paInt16,
 channels=wf.getnchannels(),
 rate=wf.getframerate(),
 output=True)

# 读取文件并播放
chunk = 1024
data = wf.readframes(chunk)
while data:
 stream.write(data)
 data = wf.readframes(chunk)

# 关闭流
stream.stop_stream()
stream.close()
p.terminate()

PyAudio的高级功能

回调模式（Callback Mode）： PyAudio 提供了回调模式来处理音频流。在这种模式下，你可以通过定义回调函数来实时处理录制或播放的音频数据。例如，你可以实时对音频数据进行处理或应用某些效果（如滤波、增益等）。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import pyaudio

def callback(in_data, frame_count, time_info, status):
 # 处理音频数据
 print("Recording...")
 return (in_data, pyaudio.paContinue)

p = pyaudio.PyAudio()

# 打开输入流
stream = p.open(format=pyaudio.paInt16,
 channels=1,
 rate=44100,
 input=True,
 frames_per_buffer=1024,
 stream_callback=callback)

stream.start_stream()

# 等待流结束
while stream.is_active():
 pass

stream.stop_stream()
stream.close()
p.terminate()

PyAudio的应用场景

音频录制与播放：用来创建简单的音频应用程序，进行声音的录制和回放。
语音识别：结合其他语音识别库（如 speech_recognition）可以实现语音识别功能。
实时音频处理：可以实时分析、修改或增强音频数据。
声音特效处理：可以在录制或播放过程中加入音效，如回声、变调等。

PyAudio与其他音频库对比

vs. wave: wave 模块主要用于处理静态的音频文件，而 PyAudio 支持音频流，能够进行实时录音与播放。
vs. soundfile: soundfile 更适用于处理已保存的音频文件的读写操作，而 PyAudio 更擅长实时音频流的处理。

注意事项

在不同平台上安装 PyAudio 可能需要额外的步骤。例如，Windows 上可能需要安装 PortAudio 的依赖项。
PyAudio 并不支持直接播放 MP3 等压缩音频格式。如果需要播放其他格式的音频，可能需要使用其他库如 pygame 或 pydub。

小结

总的来说，PyAudio 是一个非常强大的库，适合用于音频处理和实时音频应用，尤其在需要直接与麦克风或扬声器交互时，提供了非常简洁的接口。

stop_stream与start_stream

可能会有同学好奇，在上面的示例代码中，为什么只看见stream.stop_stream而没有看见stream.start_stream呢，如果只有停止流的操作，为什么没有开启流的操作，流在哪里被开启了呢？

PyAudio 中的 stream.start_stream() 和 stream.stop_stream() 是两个重要的流控制方法，用于控制音频流的开始和停止。

在 PyAudio 的流（Stream）中，start_stream() 和 stop_stream() 方法实际上是可选的，它们的行为是与音频流的实际使用场景有关的。让我们详细解释一下这两个方法，以及为什么在某些情况下，可能看不到显式调用 start_stream()。

1. stream.start_stream() 的作用

start_stream() 方法用于启动音频流，开始录制或播放音频。它是用来显式告诉程序 “现在开始处理音频数据”。

2. stream.stop_stream() 的作用

stop_stream() 方法用于停止音频流，表示录制或播放过程结束。这对于需要显式控制音频流的结束时机的程序非常有用。

为什么 `start_stream()` 有时没被显式调用

回调模式（Callback Mode）：如果使用了回调模式（即通过设置 stream_callback 参数来传递回调函数），那么在调用 open() 方法时，音频流已经自动开始了。回调机制会在后台处理音频数据的输入和输出。因此，在这种模式下，start_stream() 是不必要的，因为流会自动启动。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


import pyaudio

def callback(in_data, frame_count, time_info, status):
 # 处理音频数据
 print("Recording...")
 return (in_data, pyaudio.paContinue)

p = pyaudio.PyAudio()

# 打开输入流并设置回调函数
stream = p.open(format=pyaudio.paInt16,
 channels=1,
 rate=44100,
 input=True,
 frames_per_buffer=1024,
 stream_callback=callback)

# 注意: 这里不需要显式调用 start_stream()
stream.start_stream() # 这行可以省略，回调模式会自动启动

# 等待流结束
while stream.is_active():
 pass

stream.stop_stream()
stream.close()
p.terminate()

在这个例子中，start_stream() 虽然可以显式调用，但在使用回调模式时，可以省略，因为 PyAudio 会在底层自动处理流的启动和停止。

默认自动启动（在非回调模式下）：在非回调模式（例如通过 stream.read() 或 stream.write() 进行音频数据的读取和写入）中，start_stream() 也是隐式调用的。在创建音频流时，open() 方法会自动启动流，并开始数据的录制或播放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import pyaudio

p = pyaudio.PyAudio()

# 设置流参数
stream = p.open(format=pyaudio.paInt16,
 channels=1,
 rate=44100,
 input=True,
 frames_per_buffer=1024)

# 此时，流已经自动启动
data = stream.read(1024) # 录音
stream.stop_stream()
stream.close()
p.terminate()

在这个例子中，open() 已经自动启动了流，调用 stream.read() 只是触发音频数据的读取过程，而不需要显式调用 start_stream()。

小结

回调模式：当你使用回调函数时，PyAudio 会自动管理音频流的开始和停止。因此，通常不需要显式调用 start_stream()，而只需要设置 stream_callback 并开始流的处理。
非回调模式：即便是非回调模式，open() 方法有时也会自动开始音频流，尤其是在调用 stream.read() 或 stream.write() 时，不需要显式调用 start_stream()。

但是，在一些场景下，尤其是自定义更复杂的音频控制时，start_stream() 和 stop_stream() 还是很有用的，特别是当你需要手动控制音频流的启动与停止时。

谁开启的麦克风或扬声器

在上面的示例代码中，敏锐的读者可能会发现，似乎没有发现那里调用了麦克风或扬声器，合理猜测，直接告诉我们，应该是PyAudio库调用了硬件设备，但真是如此吗，如果是，那么又是怎么调用的呢？

我们以上面的代码为例，究竟是谁调用了麦克风，开启了录音

音频的录制是通过 pyaudio 库来实现的，调用麦克风硬件的部分是由 pyaudio 库中的 PyAudio 类和它的 open() 方法来完成的。具体的过程是这样的：

调用麦克风硬件的关键步骤：

pyaudio.PyAudio(): 这个步骤创建了一个 PyAudio 对象。这个对象是与音频硬件交互的主要接口，它会管理音频流（包括录音流和播放流），并负责配置音频设备。
p.open(): open() 方法是用来打开一个音频流的，这个流可以是输入流（例如录音）或者输出流（例如播放音频）。在上面的代码中，p.open() 被用来打开一个输入流，用于录制音频。
1 2 3 4 5

stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)
关键参数：
- format=FORMAT：指定音频数据的格式，通常为 16 位 PCM 编码（pyaudio.paInt16）。
- channels=CHANNELS：指定录音的通道数，1 表示单声道，2 表示立体声。
- rate=RATE：指定采样率，通常选择 44100 Hz，这是 CD 音质的标准采样率。
- input=True：这告诉 pyaudio 创建一个输入流，也就是通过麦克风录音。如果将其设置为 False，则会创建输出流，用于播放音频。
- frames_per_buffer=CHUNK：指定每次读取的音频块的大小，通常是 1024 或 2048。
此时，pyaudio 会通过系统的音频接口与麦克风硬件进行连接，并开始接收音频数据。具体而言，pyaudio 会通过操作系统调用音频驱动程序来访问麦克风硬件。操作系统（如 Windows、Linux、macOS）会提供接口给 pyaudio 来处理与硬件的交互。
stream.read(CHUNK): stream.read(CHUNK) 方法是用来从音频流中读取音频数据的。这里的 CHUNK 表示每次读取的音频数据的大小，也就是说它会以一定的时间间隔（根据 CHUNK 的大小）从麦克风捕捉音频数据。

通过连续调用 stream.read()，程序不断地从麦克风获取音频数据，并将这些数据存储到 frames 列表中。

总结：

谁调用了麦克风硬件？ 实际上是 pyaudio 库调用了麦克风硬件。pyaudio 作为一个高层的音频处理库，封装了与操作系统音频接口的交互。操作系统的音频驱动程序在幕后管理与麦克风硬件的连接和数据传输。
如何调用的？
- 通过 pyaudio.PyAudio() 创建的 PyAudio 实例。
- 使用 p.open() 方法创建音频输入流（input=True），并通过该流接收来自麦克风的音频数据。
- 最终使用 stream.read() 不断地从麦克风获取音频样本。

这样，pyaudio 库就可以通过操作系统和驱动程序，控制麦克风硬件进行录音了。

基于PyQt开发的脚本集合包（十二）

Sat, 14 Dec 2024 18:03:00 +0800

前言

这是音频编解码器的第三篇文章，也是收官文章，上一篇文章中，我们讲了如何制作一个自定义的特色进度条，现在，我们需要将进度条的刷新与编解码器的进度绑定起来，如此进度条才有意义，因为编解码器比较吃算力（虽然看起来ADPCM的算法非常的简单，但是奈何笔者采用的是python脚本通过循环调用C编译的exe可执行文件来实现的编码，因此算上python本身的性能，加上反复调用exe可执行文件的系统操作开销，导致ADPCM的计算时间也是不可忽视的，尤其在大数据量时），因此我们需要对编解码器单独开一个子线程跑，这样，在编解码器运行时，QT界面也能正常使用不受影响。既然编解码器是由子线程跑，那么为何不也为进度条开一个子线程，两个之间沟通消息，这样编码器与进度条的运行都不会影响QT界面的运行，而且也给进度条的使用提供了一个范式，以后再有其它功能需要使用进度条时复制粘贴即可。

Python中的线程

Python处理线程的模块有两个：thread 和 threading。Python 3已经停用了 thread模块，并改名为 _thread 模块。Python 3在 _thread 模块的基础上开发了更高级的 threading 模块，因此我们现在用的线程模块都是 threading 模块。

创建线程

1

threading.Thread(target=None, name=None, args=(), kwargs={})

target 指要创建的线程的方法名，name 指给此线程命名，命名后可以调用 threading.current_thread().name 方法输出该线程的名字， args/kwargs 指 target 指向的方法需要传递的参数，必须是元组形式，如果只有一个参数，需要以添加逗号。

线程之间的消息传递

线程与线程之间的通信是一个常见的需求。Python提供了几种方法来实现进程与进程之间的通信，常见的方式包括：queue.Queue、threading.Event、threading.Lock等同步原语。

使用 `queue.Queue` 进行线程通信

queue.Queue 是线程安全的队列，适合用于线程之间的数据传递。你可以在子线程中将数据放入队列，然后在主线程中读取。

示例代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


pythonCopy Codeimport threading
import queue
import time

# 子线程函数
def worker(q):
 for i in range(5):
 time.sleep(1) # 模拟一些工作
 q.put(f"Message {i}") # 将消息放入队列
 print(f"Worker: Sent message {i}")

# 主线程
def main():
 # 创建一个队列
 q = queue.Queue()

 # 创建并启动子线程
 t = threading.Thread(target=worker, args=(q,))
 t.start()

 # 主线程从队列中接收消息
 for _ in range(5):
 msg = q.get() # 阻塞直到队列中有数据
 print(f"Main Thread: Received {msg}")

 t.join() # 等待子线程结束

if __name__ == "__main__":
 main()

解释：

子线程 worker 将一些消息放入队列 q 中。
主线程从队列中获取消息并打印。queue.get() 是阻塞的，直到队列中有新的数据。
q.put() 和 q.get() 是线程安全的，可以在多个线程之间安全地交换数据。

使用 `threading.Event` 进行线程通信

threading.Event 是一个简单的同步原语，允许线程在等待某个条件发生时进行通信。例如，主线程可以等待子线程完成某些操作，或者子线程可以通知主线程某个事件已经发生。

示例代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


pythonCopy Codeimport threading
import time

# 子线程函数
def worker(event):
 time.sleep(2) # 模拟一些工作
 print("Worker: Setting event")
 event.set() # 设置事件，通知主线程

# 主线程
def main():
 # 创建一个事件对象
 event = threading.Event()

 # 创建并启动子线程
 t = threading.Thread(target=worker, args=(event,))
 t.start()

 print("Main Thread: Waiting for event")
 event.wait() # 阻塞，直到子线程设置事件
 print("Main Thread: Event received")

 t.join() # 等待子线程结束

if __name__ == "__main__":
 main()

解释：

子线程在执行完某些任务后调用 event.set() 来通知主线程。
主线程使用 event.wait() 来等待事件的发生，wait() 会阻塞直到事件被设置。

使用 `threading.Lock` 和共享变量

如果需要在多个线程之间共享一些资源（如变量），可以使用 threading.Lock 来避免竞争条件（race condition），确保数据的一致性。

示例代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


pythonCopy Codeimport threading
import time

# 共享变量
shared_data = 0
lock = threading.Lock()

# 子线程函数
def worker():
 global shared_data
 for _ in range(5):
 time.sleep(1) # 模拟工作
 with lock: # 使用锁保护共享资源
 shared_data += 1
 print(f"Worker: Incremented shared_data to {shared_data}")

# 主线程
def main():
 # 创建并启动子线程
 t = threading.Thread(target=worker)
 t.start()

 t.join() # 等待子线程结束

 # 访问共享资源
 with lock: # 同样使用锁保护共享资源
 print(f"Main Thread: Final shared_data is {shared_data}")

if __name__ == "__main__":
 main()

解释：

shared_data 是一个主线程和子线程共享的变量。
使用 threading.Lock() 来确保只有一个线程能够访问和修改共享数据，从而避免了数据的竞争。

使用 `threading.Condition` 进行更复杂的通信

threading.Condition 是一种更复杂的同步机制，允许线程在某个条件发生时进行等待和通知。它结合了 Lock 和 Event 的特性，适用于更复杂的线程间协调问题。

示例代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


pythonCopy Codeimport threading
import time

# 共享资源和条件变量
shared_data = 0
condition = threading.Condition()

# 子线程函数
def worker():
 global shared_data
 time.sleep(2) # 模拟工作
 with condition:
 shared_data = 42 # 修改共享数据
 print("Worker: Shared data set to 42")
 condition.notify() # 通知主线程

# 主线程
def main():
 # 创建并启动子线程
 t = threading.Thread(target=worker)
 t.start()

 with condition:
 print("Main Thread: Waiting for condition")
 condition.wait() # 等待通知
 print(f"Main Thread: Shared data is {shared_data}")

 t.join() # 等待子线程结束

if __name__ == "__main__":
 main()

解释：

子线程修改共享数据并使用 condition.notify() 通知主线程。
主线程通过 condition.wait() 等待子线程通知，直到条件满足才继续执行。

接下来我们看一下编解码器UI是如何调用编解码器以及编解码器如何与进度条进行消息传递的

编码器UI设计

编码器的UI布局在上一篇文章中已经阐述过，在这里就不做过多的赘述，直接放上代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91


import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtSvg import *
import threading
import queue

from component.btnStyle import *
from component.editStyle import *
from component.getPath import *
from component.progressBar import *
from tools.adpcmcoder.adpcmEncRun import *
from tools.adpcmcoder.adpcmDecRun import *

class WAcodec(QWidget):
 def __init__(self):
 super().__init__()
 self.filePaths = ['']
 self.initUI()

 def initUI(self):
 self.layout = QVBoxLayout()
 self.setLayout(self.layout)
 # 文件选择
 self.filelayout = QHBoxLayout()
 self.lable = QLabel("请选择文件",self)
 self.filelayout.addWidget(self.lable)
 self.input = QLineEdit(self)
 LineEditStyle(self.input)
 self.filelayout.addWidget(self.input)
 self.choosebtn = QPushButton("选择文件",self)
 btnReleaseStyleA(self.choosebtn)
 self.choosebtn.clicked.connect(self.getpath)
 self.filelayout.addWidget(self.choosebtn)
 self.layout.addLayout(self.filelayout)

 # 编码器选择
 self.codeclayout = QHBoxLayout()
 self.codeccb = QComboBox(self)
 self.codeccb.addItem('ADPCM')
 self.codeclayout.addWidget(self.codeccb)
 self.layout.addLayout(self.codeclayout)

 # 编码解码选择
 self.encdeclayout = QHBoxLayout()
 self.encdecbtn = QPushButton("编码",self)
 btnReleaseStyleA(self.encdecbtn)
 self.encdecbtn.clicked.connect(self.encodeRun)
 self.encdeclayout.addWidget(self.encdecbtn)
 self.decbtn = QPushButton("解码",self)
 btnReleaseStyleA(self.decbtn)
 self.decbtn.clicked.connect(self.decodeRun)
 self.encdeclayout.addWidget(self.decbtn)
 self.layout.addLayout(self.encdeclayout)

 # 进度条
 self.runlayout = QVBoxLayout()
 self.progress_bar = ProgressBar() # 自定义进度条
 self.runlayout.addWidget(self.progress_bar)

 self.layout.addLayout(self.runlayout)


 def getpath(self):
 get_path(self)
 self.input.setText(self.filePaths[0])

 def encodeRun(self):
 if self.input.text() == '':
 print("未选择文件")
 return

 q = queue.Queue()
 self.progress_bar.init_grids()

 if self.codeccb.currentText() == 'ADPCM':
 # 以多线程并发的形式规避ADPCM编解码时带来的卡顿问题
 threading.Thread(target=ADPCMencodeRun, args=(self.input.text(),q), daemon=True).start()
 threading.Thread(target=self.progress_bar.update_progress,args=(q,), daemon=True).start()
 def decodeRun(self):
 if self.input.text() == '':
 print("未选择文件")
 return

 q = queue.Queue()
 self.progress_bar.init_grids()

 if self.codeccb.currentText() == 'ADPCM':
 threading.Thread(target=ADPCMdecodeRun, args=(self.input.text(),q), daemon=True).start()
 threading.Thread(target=self.progress_bar.update_progress,args=(q,), daemon=True).start()

PyQt5部分的代码已经是老朋友了，获取文件，下拉选框，两个按钮。进度条的设计在上一篇文章中详细介绍过，这里着重介绍按钮按下时，创建线程执行编解码器与进度条

以解码器为例：

使用threading.Thread函数创建线程，target传入线程需要调用的方法，即ADPCMdecodeRun，解码启动脚本，args向ADPCMdecodeRun方法传入参数，文件路径与队列对象，队列对象用于保存和传输消息，daemon表示该线程是否为守护线程，如果是，则它会在主线程结束时自动终止，哪怕它的任务没有结束，如果不是，则如果它的任务没有结束，程序会等待它执行完毕才会结束
.start表示启动该线程

解码器启动脚本

介绍完如何开启线程与线程之间如何进行通信，那么我们接下来就实现解码器的启动脚本，并在解码器的启动脚本中做一些小小的设计：

设置一个percent，来记录当前已解码的进度，percent记录的是 已解码行数/总行数
因为进度条共有100个格子来表示0%,1%,...,100%，因此进度条应接收整数的1，2，3，4，...，进而percent应该是整数，且+1后通过put方法，向进度条传递消息
进度条通过get方法阻塞自己，等待解码器的消息，当解码器传递来新的消息时，就会触发更新进度条。

接下来我们看编码器的启动脚本代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


import subprocess
import queue
import sys

def ADPCMdecodeRun(filepath,q):
 print("ADPCM decode start")
 with open('workspaces/pcm.txt', 'w') as fw:
 fw.close()

 error = []
 linecount = 0
 totalcount = 0
 progressblock = 0
 percent = 1
 if sys.platform == 'win32': # 仅在 Windows 上使用这个设置
 creation_flags = subprocess.CREATE_NO_WINDOW
 else:
 creation_flags = 0 # 在其他平台上没有必要使用这个参数
 ###···················DEXP ADPCM解码··························
 with open(filepath,'r') as f:
 print("ADPCM decoding ...")
 adlist = []
 adlist.append('00')
 adlist.append('00')
 lines = f.readlines()
 totalcount = len(lines)
 progressblock = totalcount / 100
 for line in lines:
 for i in range(len(line)):
 if line[i] == ' ' or line[i] == '\n':
 adlist.append(line[i-2:i])
 # 若打包，用下面路径
 #args = ["_internal/res/AdpcmCodec/adpcmdecoder.exe"] + adlist
 # 若调试，用下面路径
 args = ["src\\tools\\adpcmcoder\\adpcmdecoder.exe"] + adlist
 #print(args)
 result = subprocess.run(args, capture_output=True,text=True,creationflags=creation_flags)
 #print("STDOUT:", result.stdout)
 #print("liencount:",linecount)
 if result.returncode != 0:
 error.append(linecount)
 else:
 hex_list = result.stdout.split()
 adlist.clear()
 adlist.append(hex_list[len(hex_list)-2])
 adlist.append(hex_list[len(hex_list)-1])
 hex_list.pop()
 hex_list.pop()
 hex_list = ' '.join(hex_list)
 with open('workspaces/pcm.txt','a') as fw:
 fw.write(hex_list)
 fw.write("\n")
 fw.close()
 linecount += 1
 if linecount > percent * progressblock:
 #msg = f"已完成{percent}%"
 q.put(percent)
 #print("msg:",msg)
 #print("linecount:",linecount)
 percent += 1
 q.put(percent)
 print("ADPCM decode end")

在这段代码中，可以看到，ADPCMdecodeRun方法除了接收文件路径外，还接收一个q变量，即Queue对象，这样，在该线程中可以使用队列对象来传递消息，我们来依次解释一下代码：

写文件，使用w打开后直接关闭，达到一个创建文件，若文件存在，则清空文件中的内容的目的（因为后面我们用a命令在文件中追加内容，如果不提前清理文件，则会在同名文件下追加内容导致数据会乱）
默认情况下，Windows会弹出命令窗口（CMD）以运行程序，在此python脚本中，因为会循环调用CMD来启动解码器adpcmdecoder.exe，因此会导致CMD窗口被反复打开又关闭。为避免这个CMD窗口弹出，可以通过设置subprocess的creation_flags参数来隐藏它。具体来说，你可以使用 subprocess.CREATE_NO_WINDOW 来防止命令行窗口的出现。这对于 Windows 系统特别有效。
totalcount获取总行数，progressblock为总行数的1%
循环读取数据，并将数据放入解码器中，注意，这里使用的是ADPCM解码器，根据往期内容，我们的解码器接收的参数为：函数名称，valprev，index，data_1，data_2，….，data_n。valprev与index初始化值为0。
如果解码失败或遇到错误参数，导致解码器无法正常解码，解码器会返回非0数字，脚本会记录下当前未被正确解码的行数，保存在error列表中
对解码后的数据做分割处理，在这里返回的数据保存方式为：data_0，data_1，data_2，….，data_n，valprev，index，这与输入的刚好相反，将valprev与index这两个参数放在最后，因为历史遗留问题，笔者没(lan)有(de)改动。
将valprev与index保存在adlist列表的开头，用以下一次解码，并在hex_list列表中弹出这两个值，因为写入数据时不需要这两个值，这两个是解码时产生的中间值，不是数据。
将数据写入文件中，a表示在末尾追加内容
linecount记录当前行数，如果linecount超过了progressblock * percent，则执行percent ++ 操作。例如：文件中共有100行数据，则totalcount=100，progressblock=10，现在当linecount=11时，则会导致linecount > percent * progressblock，则会对percent+1，此时percent= 1
如果上面的条件达成，则会将percent=1的消息通过q.put方法放到队列中
此时，在进度条对象ProgressBar中的update_progress方法中的percent = q.get()在阻塞，检测是否有新消息，现在得到了新消息，则将消息赋值给percent，如此，就实现了解码的进度传递给进度条组件的操作。

以上便是解码启动器脚本，下面给出编码器启动脚本，原理相同，代码改动不大，笔者就不做赘述

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


import subprocess
import queue
import sys

def ADPCMencodeRun(filepath,q):
 print("ADPCM encode start")
 with open('workspaces/adpcm.txt', 'w') as fw:
 fw.close()

 error = []
 linecount = 0
 totalcount = 0
 progressblock = 0
 percent = 1
 if sys.platform == 'win32': # 仅在 Windows 上使用这个设置
 creation_flags = subprocess.CREATE_NO_WINDOW
 else:
 creation_flags = 0 # 在其他平台上没有必要使用这个参数
 ###···················DEXP ADPCM编码··························
 with open(filepath,'r') as f:
 print("ADPCM encoding ...")
 adlist = []
 adlist.append('00')
 adlist.append('00')
 lines = f.readlines()
 totalcount = len(lines)
 progressblock = totalcount / 100
 for line in lines:
 for i in range(len(line)):
 if line[i] == ' ' or line[i] == '\n':
 adlist.append(line[i-4:i])
 # 若打包，用下面路径
 #args = ["_internal/res/AdpcmCodec/adpcmencoder.exe"] + adlist
 # 若调试，用下面路径
 args = ["src\\tools\\adpcmcoder\\adpcmencoder.exe"] + adlist
 #print(args)
 result = subprocess.run(args, capture_output=True,text=True,creationflags=creation_flags)
 #print("STDOUT:", result.stdout)
 #print("liencount:",linecount)
 if result.returncode != 0:
 error.append(linecount)
 else:
 hex_list = result.stdout.split()
 adlist.clear()
 adlist.append(hex_list[len(hex_list)-2])
 adlist.append(hex_list[len(hex_list)-1])
 hex_list.pop()
 hex_list.pop()
 hex_list = ' '.join(hex_list)
 with open('workspaces/adpcm.txt','a') as fw:
 fw.write(hex_list)
 fw.write("\n")
 fw.close()
 linecount += 1
 if linecount > percent * progressblock:
 #msg = f"已完成{percent}%"
 q.put(percent)
 #print("msg:",msg)
 #print("linecount:",linecount)
 percent += 1
 q.put(percent)
 print("ADPCM encode done")

总结

这是一个简单的实现线程之间消息传递的模式，在我的实践中是可行的，至此，我们实现了音频编解码器的功能模块，并实现了一个新的组件，即进度条。当然，这个功能模块尚不完美，后续还会持续地检查并优化（如果有优化方法的小伙伴也欢迎私信我）。在这里我整理了几点不足：

首先，ADPCM的编解码器通过subprocess的方法循环调用确实有些笨拙，也比较吃性能，在频繁地启动编码器过程中，往往会损失大量的时间
其次，在实际测试过程中ADPCM的编解码速度时好时坏，同一份数据，有时候会非常慢，有时候又会非常快，我通过观察脚本的硬件调度，发现内存占用比没有发生很大的变化，但是GPU的调度会有明显变化，当GPU持续被分配给脚本时，编解码的速度会非常快，当GPU没有被分配给脚本时，编码速度会变得异常慢。为什么会产生GPU分配的差异原因笔者还没查出来，在代码中，Python也没有显式地说明在什么环节会调用GPU，笔者也没有刻意地去调用GPU，如果直到原因的同学可以私信我。
percent这种简易（甚至说简陋）的粗暴计算编解码进度的方法实在有些拙劣，可能还会产生其它对进度预估错误的情况发生。我推测可能会产生bug的一种场景是，当adpcm编解码速度过快，进度条还未处理上一条消息的绘制时，下一条消息就来了，可能会导致缺画漏画的情况，笔者还没测出，但笔者会持续改进算法，也希望各位大佬能够指点一二。

到目前为止，音频编解码器模块的代码已经全部出来。

我们先从UI界面开始，通过PrimeWindow的stack切换到音频编解码器模块，即本文出现的第一个代码，那里实现了编解码器功能区的UI

代码存放的工程目录如下：
之后，便是音频编码器的启动脚本与解码器的启动脚本都在本文中展示了

工程目录如下：
再者，到进度条样式的实现，在上一篇文章中实现了

工程目录如下：
最后，到编解码器的实际实现，这部分是通过C程序实现的，在上上篇文章中实现了

工程目录如下：

阅读完这三篇文章，加上熟悉本系列前期的基础，即工程布局架构，你可以轻松复制我的代码，实现自己的音频编解码器，快来试试吧！有任何疑问请联系我，祝你变得更强！

因为语音编解码器功能模块的实现较为复杂，而且也增加了一些新的UI设计，因此知识点与代码都无法在一篇文章中全部呈现，但将代码分散在不同的文章里又让一些基础比较薄弱的同学难以快速上手，因此，如若对此模块感兴趣的人比较多，笔者将在这三篇文章的基础上，单独开一篇新的博文，梳理代码的布局以及如何在自己的机器上跑起来，让新手小白也能复制即用。

基于PyQt开发的脚本集合包（十一）

Fri, 13 Dec 2024 13:26:00 +0800

前言

这是实现音频编解码器功能模块的第二篇文章，在本文中，我们将实现自定义的特色进度条以及简单介绍编码器的UI布局，本文主要实现特色进度条，在本文中，我们会涉及到的知识点有：特色进度条的实现原理，一个python生成器的用法，PyQt的控件绘制机制。本文仅介绍编解码器UI的布局，因为实现UI时会用到开线程的部分，因此本文先不展示。

本次笔者设计的特色进度条，是涂格子形式的进度条，当进度增加时，进度条内的方格会被随机涂上颜色，供大家参考。

UI框架

如下图所示：

编码器的UI布局同样为垂直分布
在第一层级，由经典的选择文件构成，这个选择文件的布局样式已经在本系列中多次出现
一个下拉选择框，目前只有ADPCM一个算法可供选择
两个按钮水平布局，编码按钮启动编码器，解码按钮启动解码器
编解码器读取选中的文件，从文件中读取数据。注意，文件最好是txt文件格式，数据是十六进制数1字节为单位，以空格分隔开，可选择一帧数据一行，如下图所示：
解码器会在workspaces目录下生成pcm.txt数据文件，其中包含了解码后的PCM数据，以文本形式保存，后续将其放入pcm构建器中可生成二进制文件，在PCM播放器中播放即可。
编码器会在workspaces目录下生成adpcm.txt数据文件，其中包含了编码后的ADPCM数据，以文本形式保存，后续如何处理数据，可自行决定。
最下方是进度条，由20*5共100个方格组成，在未启动状态下为灰色，当开始解码或编码时，编码进度每增加1%，那么就会随机涂蓝一个格子，在进度为100%时，即编码完成，则所有格子全部为蓝色。
当重新开始编码或解码时，格子会重新初始化，全部被重新涂成灰色。

进度条展示

下面是正在解码过程中的进度条展示，在右边的日志展示区中可以看到，正在进行ADPCM解码，在功能区中，下方进度条在随机选择格子涂蓝，将这些以显示当前进度

下面是解码结束后的进度条样式，可以看到，在右边的日志区中，显示ADPCM decode end，adpcm解码完成，下方的进度条已被完全涂成蓝色。

代码详解

下面给出进度条的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


import sys
import random
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QColor, QPainter, QPainterPath
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton
import queue
class ProgressBar(QWidget):
 def __init__(self):

 super().__init__()
 self.setFixedSize(640, 160) # 设置进度条的大小
 self.grid_size = 32 # 每个方格的宽度和高度
 self.total_grids = (self.width() // self.grid_size) * (self.height() // self.grid_size) # 方格总数
 self.lit_grids = 0 # 当前已点亮的方格数量
 self.grid_status = [False] * self.total_grids # 每个方格是否被点亮

 def init_grids(self):
 self.lit_grids = 0 # 当前已点亮的方格数量
 self.grid_status = [False] * self.total_grids
 self.update() # 更新进度条绘制

 def update_progress(self,q):
 """随机点亮一个未点亮的方格"""
 while True:
 percent = q.get()
 if self.lit_grids < self.total_grids and percent <= 100:
 # 随机选择一个未点亮的方格
 unlit_grids = [i for i, lit in enumerate(self.grid_status) if not lit]
 random_grid = random.choice(unlit_grids)
 self.grid_status[random_grid] = True # 点亮该方格
 self.lit_grids += 1 # 增加已点亮的方格数量
 self.update() # 更新进度条绘制
 if percent == 100:
 break

 else:
 break


 def paintEvent(self, event):
 """自定义绘制进度条"""
 painter = QPainter(self)
 painter.setRenderHint(QPainter.Antialiasing) # 启用抗锯齿效果，使边角更平滑

 # 绘制方格
 for row in range(self.height() // self.grid_size):
 for col in range(self.width() // self.grid_size):
 x = col * self.grid_size
 y = row * self.grid_size
 # 计算当前方格的索引
 index = row * (self.width() // self.grid_size) + col
 if self.grid_status[index]:
 color = QColor(144, 203, 251) # 已点亮的部分，蓝色
 else:
 color = QColor(224, 224, 224) # 未点亮的部分，灰色

 painter.fillRect(x, y, self.grid_size, self.grid_size, color) # 绘制方格

 painter.end()

我们来解释一下上面的代码：

在__init__方法中，设置了一些基础配置，进度条的大小，方格的大小，方格的总数，已点亮的方格数，每个方格的状态（是否被点亮了），值得注意的是，方格的总是是通过进度条的长除以方格的长，进度条的宽除以方格的宽然后相乘的来的，这里直接翻译为20*5 = 100
init_grids方法重新初始化方格的基础配置，归零已点亮的方格数量，擦除方格的状态，并重新绘制进度条，即恢复初始状态
update_progress方法用以更新进度，可以看到，该函数接收一个q参数，该参数为一个队列对象，用以线程之间的沟通（线程方面我们下篇文章讨论），此处做一个while的死循环，从队列中获取来自另一个线程的消息，这个操作是阻塞的，也就是说，当未从队列中获取新的消息，则线程不会继续进行下一条指令。
如果已经点亮的方格数小于全部方格数，且进度≤100%，则执行以下操作，随机选择一个未点亮的方格，标志为点亮
unlit_grids = [i for i, lit in enumerate(self.grid_status) if not lit]，解释一下这一段代码：
- enumerate(self.grid_status)将会返回一个生成器，生成的是每个元素的索引i和对应的值lit，例如：假设self.grid_status = [True, False, True, Flase]，那么生成器将会返回，(0,True),(1,False),(2,True),(3,False)
- for i, lit in enumerate(self.grid_status)是一个for循环，用来遍历enumerate(self.grid_status)返回的每一个(i,lit)元组，i是索引，lit是self.grid_status中对应的状态值
- if not lit这个条件判断会检查lit是否为False，如果为False，就会被加入到列表unlit_grids中
- 总的来说，这是整个列表推导式的语法，它会创建一个包含所有符合条件if not lit的元素索引i的新列表
random.choice方法在unlit_grids中随机选择一个方格
将选择的的方格状态设置为点亮
增加已点亮的方格数量
更新进度条绘制
如果进度条达到100%，则直接退出该函数，不再循环，也不再接收来自其它线程的消息
paintEvent方法是用以绘制进度条的，创建一个在PyQt中可绘制的对象QPainter。
两层for循环，计算现在的位置，确定这个位置的方格是以点亮还是未点亮，确定颜色，绘制方格。
painter.end方法结束绘制

总结

进度条的更新实际上是对控件的重新绘制

paintEvent在什么时候被调用？

paintEvent 是一个 Qt 事件处理函数，它在 需要重新绘制组件时 被自动调用。Qt 会在以下几种情况下触发 paintEvent：

窗口或控件首次显示时：

当窗口或控件第一次显示时，paintEvent 会被触发，负责绘制控件的初始状态。

控件大小发生变化时：

如果控件的大小发生了变化（例如，窗口调整大小），paintEvent 会被调用来重新绘制控件，以适应新的尺寸。

调用 update() 或 repaint() 时：

当你调用 update() 或 repaint() 方法时，Qt 会标记该控件为“需要重绘”，并会在下一个事件循环中触发 paintEvent。

其他因素：

如果控件的内容发生了变化，或者某些部分被遮挡并随后暴露出来，Qt 会重新触发 paintEvent 来重新绘制这些区域。例如，当窗口被部分遮挡后再显示出来时，Qt 会调用 paintEvent 来刷新被遮挡的部分。

在上面的代码中，每次更新进度条的状态时，调用self.update，重新绘制控件。

如果不适用self.update，而是直接调用paintEvent绘制进度条可以吗？

直接调用 paintEvent 来重绘进度条并不是一种推荐的做法。原因在于，Qt 的事件机制是自动管理绘制过程的，而直接调用 paintEvent 会绕过事件系统，可能导致一些问题。下面我将详细解释原因和影响。

Qt 的绘制机制：

在 Qt 中，paintEvent 由事件循环自动管理，通常不需要直接调用。当你调用 self.update() 时，Qt 会将控件标记为“需要重绘”，并在合适的时机调用 paintEvent。

self.update() 会触发一个绘制事件，但不会立即调用 paintEvent，而是将重绘请求加入事件队列，稍后由 Qt 的事件循环处理。这样做的好处是，Qt 会合理地合并多个绘制请求，避免频繁的重复重绘，提高性能。

直接调用 paintEvent 的问题：

如果你直接调用 paintEvent，就会绕过 Qt 的事件循环和绘制机制。paintEvent 通常是由系统在适当时机（如控件需要重绘时）自动触发的。

直接调用paintEvent可能会导致：

绘制不一致：因为 Qt 的绘制机制已经负责了缓存和重绘的时机，直接调用 paintEvent 可能会与其他重绘请求冲突，导致绘制不稳定。

不符合最佳实践：Qt 推荐使用 update() 来请求重绘，因为它利用了 Qt 内部的绘制优化策略。如果你直接调用 paintEvent，可能会破坏这些优化。

通过消息队列传递更新消息

进度条的更新实际上需要与编解码器的编解码进度相关，因为编解码器吃算力，因此不建议将编解码器放在主线程中运行，所以对编解码器开了子线程运行，消息的互传需要通过消息队列来进行。关于线程问题，我们将在下一期内容时更详细地讲解。

祝你变得更强！

因为语音编解码器功能模块的实现较为复杂，而且也增加了一些新的UI设计，因此知识点与代码都无法在一篇文章中全部呈现，但将代码分散在不同的文章里又让一些基础比较薄弱的同学难以快速上手，因此，如若对此模块感兴趣的人比较多，笔者将在这三篇文章的基础上，单独开一篇新的博文，梳理代码的布局以及如何在自己的机器上跑起来，让新手小白也能复制即用。

基于PyQt开发的脚本集合包（十）

Thu, 12 Dec 2024 19:26:00 +0800

前言

距离上次更新PyQt实战系列隔了好久，因为现实中比较忙，而且确实是存货已经用完，现在对脚本集合包更新了一些新的内容，包括：JSON数据的处理，ADPCM音频编解码，PCM二进制文件构建以及PCMM音频播放功能，此外，还有一个数据加密解密算法，与笔者之前的文章《逆向工程实战，在反汇编中发生的事》中的算法一致，是笔者在反汇编的学习中无意间发现的一种数据加密算法，简单且有效，当初逆向该算法时花了不少时间，总之，这些内容后续都会讲到！

JSON数据处理UI

本功能的UI设计十分简单，用到的全是PyQt5实战系列提及过的内容，因此本文将不再重复讲解UI界面的代码，但是代码依然会贴出来，如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtSvg import *

from component.btnStyle import *
from component.editStyle import *
from component.getPath import *
from tools.wiresharckJsonProcess import *


class WwiresharkJsonProc(QWidget):
 def __init__(self):
 super().__init__()
 self.filePaths = ['']
 self.initUI()

 def initUI(self):
 self.JsonProcesslayout = QVBoxLayout()
 self.setLayout(self.JsonProcesslayout)
 # 文件选择
 self.filelayout = QHBoxLayout()
 self.lable = QLabel("请选择文件",self)
 self.filelayout.addWidget(self.lable)
 self.input = QLineEdit(self)
 LineEditStyle(self.input)
 self.filelayout.addWidget(self.input)
 self.choosebtn = QPushButton("选择文件",self)
 btnReleaseStyleA(self.choosebtn)
 self.choosebtn.clicked.connect(self.getpath)
 self.filelayout.addWidget(self.choosebtn)
 self.JsonProcesslayout.addLayout(self.filelayout)

 # 开始处理
 self.exebtn = QPushButton("开始处理",self)
 btnReleaseStyleA(self.exebtn)
 self.exebtn.clicked.connect(self.exebtn_press_clicked)
 self.JsonProcesslayout.addWidget(self.exebtn)

 def getpath(self):
 get_path(self)
 self.input.setText(self.filePaths[0])

 def exebtn_press_clicked(self):
 processJson(self.filePaths[0])

界面非常简单，如下所示

可以看到，在这个页面下仅有一个文件选择的组件加上一个处理的按钮。非常简单的一个页面设计，本文的重点并不在这个UI设计上，而是在wireshark的抓包数据转换成JSON格式以及python提取JSON数据。

JSON数据的来源

本文所使用的JSON数据来源于wireshark抓包，wireshark是一个网络封包分析工具，可以截取各种网络数据包，并显示数据包中的各种详细信息，常用于开发测试过程中的问题定位。但笔者并不是用wireshark来处理网络封包，而是处理低功耗蓝牙(BLE)的封包。wireshark本身并没有捕获BLE数据包的能力，但是结合特殊的dongle可以，使用NRF52832 BLE Sniffer低功耗蓝牙抓包器可以捕捉到到低功耗蓝牙的空中数据，非常实用，感兴趣的同学可以在网上查询相关信息，本文不做赘述。

这里笔者对一个数据包做了筛选，如下图所示，从机通过notify的形式向主机传递消息，消息通过handle值为0x97的特征传递给主机，这里不了解蓝牙的同学可以不用理会，以后笔者会单独出一个蓝牙系列，分享笔者的蓝牙知识。

在下面详细信息中可以看到，所选中的这一条数据，是从机通过handle为0x97的特征，向主机发送共计120个字节的value数据：3b 18 01 ....... 04 d1 1a，如果手动一条一条数据中蓝色框框的内容复制出来是非常耗时的，可以采用以下方式获取数据：

文件 → 导出分组解析结果 → As JSON

可以导出JSON格式的数据，我们展示一下JSON数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


[
 {
 "_index": "packets-2024-12-06",
 "_type": "doc",
 "_score": null,
 "_source": {
 "layers": {
 "frame": {
 "frame.section_number": "1",
 "frame.interface_id": "0",
 "frame.interface_id_tree": {
 "frame.interface_name": "COM30-4.0",
 "frame.interface_description": "nRF Sniffer for Bluetooth LE COM30"
 },
 "frame.encap_type": "186",
 "frame.time": "Dec 6, 2024 11:19:43.491844000 中国标准时间",
 "frame.offset_shift": "0.000000000",
 "frame.time_epoch": "1733455183.491844000",
 "frame.time_delta": "0.000231000",
 "frame.time_delta_displayed": "0.000000000",
 "frame.time_relative": "62.812024000",
 "frame.number": "12534",
 "frame.len": "53",
 "frame.cap_len": "53",
 "frame.marked": "0",
 "frame.ignored": "0",
 "frame.protocols": "nordic_ble:btle:btl2cap:btatt"
 },
 "nordic_ble": {
 "nordic_ble.board_id": "30",
 "nordic_ble.header": {
 "nordic_ble.plen": "46",
 "nordic_ble.protover": "3",
 "nordic_ble.packet_counter": "36765",
 "nordic_ble.packet_id": "6"
 },
 "nordic_ble.len": "10",
 "nordic_ble.flags": "0x0d",
 "nordic_ble.flags_tree": {
 "nordic_ble.crcok": "1",
 "nordic_ble.direction": "0",
 "nordic_ble.encrypted": "1",
 "nordic_ble.micok": "1",
 "nordic_ble.phy": "0",
 "nordic_ble.flag_reserved7": "0"
 },
 "nordic_ble.channel": "29",
 "nordic_ble.rssi": "-45",
 "nordic_ble.event_counter": "1158",
 "nordic_ble.time": "1172995411",
 "nordic_ble.packet_time": "296",
 "nordic_ble.delta_time": "151",
 "nordic_ble.delta_time_ss": "231"
 },
 "btle": {
 "btle.access_address": "0x27353836",
 "btle.master_bd_addr": "90:e4:68:a8:41:7c",
 "btle.slave_bd_addr": "00:00:00:08:47:2c",
 "btle.data_header": {
 "btle.data_header.llid": "0x02",
 "btle.data_header.next_expected_sequence_number": "1",
 "btle.data_header.sequence_number": "0",
 "btle.data_header.more_data": "1",
 "btle.data_header.cte_info_present": "0",
 "btle.data_header.rfu": "0",
 "btle.data_header.length": "27"
 },
 "btle.length": "27",
 "btle.l2cap_index": "132",
 "btle.connection_parameters_in": "11696",
 "btle.crc": "0xe3cc46"
 },
 "btl2cap": {
 "btl2cap.length": "23",
 "btl2cap.cid": "0x0004"
 },
 "btatt": {
 "btatt.opcode": "0x1b",
 "btatt.opcode_tree": {
 "btatt.opcode.authentication_signature": "0",
 "btatt.opcode.command": "0",
 "btatt.opcode.method": "0x1b"
 },
 "btatt.handle": "0x0036",
 "btatt.handle_tree": {
 "btatt.service_uuid16": "0x1812"
 },
 "btatt.value": "60:d8:4b:d4:62:66:d9:d5:4c:d5:5f:d6:d3:5d:63:da:64:d7:61:d8"
 }
 }
 }
 },

这么长的数据，仅仅wireshark中展示的一条数据，而我们需要的数据，仅仅是btatt.value这一个属性

1

"btatt.value": "60:d8:4b:d4:62:66:d9:d5:4c:d5:5f:d6:d3:5d:63:da:64:d7:61:d8"

而敏锐的同学可以发现，此JSON文件的开头，是[，也就是说，此JSON文件的框架是[{第一条数据},{第二条数据}....{第n条数据}...]，这种格式非常适合python通过list数据结构进行处理。

JSON数据提取

先来观察我们需要的目标数据，btatt.value，这是由多层字典嵌套在其中的，因此要依次往上查找不同层级的字典，可以发现：

__source

layers

btatt

btatt.value

是这样的一个结构。

我们现在来看代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import json

def processJson(filename):
 with open(filename, "r", encoding="utf-8") as f:
 attvalue = json.load(f)
 for i in range(len(attvalue)):
 voicevalue = attvalue[i]["_source"]["layers"]["btatt"]["btatt.value"] + "\n"
 with open("workspaces/VoiceData.txt", "a", encoding="utf-8") as f:
 f.write(voicevalue)
 print("line len: ",len(voicevalue))
 print("line count: ",len(attvalue))
 # print(data)

我们来分析一下代码：

从filename这个文件中读取数据，以utf-8编码格式解码
json.load(f)是指从f中读取数据JSON数据，解析并返回对应的Python对象（例如，字典，列表等，具体取决于JSON的结构），通过我们上面的分析，此json会被解析成python的列表（因为最外层是[]）。
循环读取attvalue列表对象
读取attvallue列表中第i个元素中的layers字典中的btatt字典中的btatt.value所对应的值，并加上一个换行符/n，最后复制给voicevalue
将voicevalue写进workspaces/VoiceData.txt文件的末尾，a表示在文件末尾写入东西，而不覆盖原来的内容。
当将所有的内容都写完时，返回每条数据的数据量以及数据总量

该方法被单独写在wiresharckJsonProcess.py文件中，存放在tools目录下，被UI页面通过import以模块导入的形式使用。

总结

本文的内容并不复杂，主要是如何从wireshark中导出JSON数据，以及如何使用python对数据进行过滤和处理，JSON是非常常用的数据传输和保存格式尤其在网络中非常常用，因此熟练的掌握看懂和处理对程序员来说是值得的，而且并不难不是吗，祝你变得更强！

基于PyQt开发的脚本集合包（九）

Fri, 08 Nov 2024 12:02:00 +0800

前言

本文笔者吸取了第一次爬取微软翻译的经验，发现在对微软翻译进行请求的时候，URL会随着会话结束而重新生成，这一点是本文需要解决的内容，且除了URL中出现的IG和IID两个数据外，在请求的表单数据中，还有key和token两个数据也在动态变化。本文旨在追踪这几个数据在何时被发送，如何被获取。

分析

首先，重新打开浏览器自带的开发者工具，随便翻译一词，让客户端发送一次翻译请求ttranslatev3，可以发现，这次URL与前一篇文章基于PyQt开发的脚本集合包（八）的又不一致

https://cn.bing.com/ttranslatev3?isVertical=1&&IG=DFFF2F46AAE0482491F67EEEB26C249C&IID=translator.5025

笔者借助开发者工具自带的搜索框进行搜索，看看我们需要的数据在哪里出现过

除了上一篇文章中提到的IG和IID两个数据外，我们还需要找到token和key两个数据，在ttranslatev3响应请求中，可以看到我们发送请求时，请求表单除了携带需要翻译的文本，翻译前的语种，翻译后的语种外，还需携带两个特殊的信息

至于tryFetchingGenderDebiasedTranslations一直为true，因此直接填写即可

IG

找到`IG`所在

首先看看IG在哪里出现过，将IG的数据DFFF2F46AAE0482491F67EEEB26C249C复制进搜索框查询，得到以下信息

可以发现，搜索出来的大部分请求中，这一串数据都是出现在URL与path中的，也就是说，这些请求中，IG数据也是被使用的，并不是出自于这些请求，继续向下滑动，找到了一个translator的包

如果你点击进去，就会发现，这其实就是访问该页面的第一个请求响应，它的html数据构建了整个页面

现在我们查看IG数据在这个响应的哪里，点击刚刚搜索的地方，会自动跳转到response出现了相同信息的地方，如下图所示：

因此，现在重新确认一下目标：目标从“找到IG数据的出处”变更为“获取IG数据”。

请求获取`IG`数据

来观察一下这个请求响应，回顾一下上一篇文章，我们在请求时需要些什么数据：

URL、User-Agent、表单数据

那我们依次来找这个请求所需要的数据，首先看标头：

URL

这个URL携带的信息很好猜，https://cn.bing.com/translator是访问的主机，即微软搜索引擎bing的翻译页面，?表示后面携带了多个参数，ref=TThis这通常表示一个参考信息或来源标识符。可能是用来跟踪用户从哪个链接访问了翻译工具，text表示默认的翻译文本，from表示翻译前的语种，to表示目标语种。可以看到，这里后面携带的三个信息，正好是打开网页时的默认信息

“输入文本”是背景，实际上并没有东西在这里。

可以猜测，每次访问这个页面，URL大概率是不会发生变化的，没有携带什么特殊的信息。经过反复的刷新和测试，验证了这个猜想。

User-Agent

为什么User-Agent会是一样的？需不需要担心它会不会变化？来看一下User-Agent的定义：

在进行网页爬虫时，User-Agent 是一个非常重要的 HTTP 请求头字段，它的主要作用是向服务器提供有关请求者（通常是浏览器或爬虫）的一些信息。具体来说，它会告诉服务器，发出请求的客户端是什么类型的设备，操作系统，浏览器等。不同的服务器和网站可能根据 User-Agent 来决定如何响应请求，比如返回不同的内容、样式，或者限制对某些类型客户端的访问。

User-Agent 的作用总结：

识别客户端： User-Agent 向服务器表明请求是由哪个客户端发出的。对于不同的浏览器、操作系统或设备，User-Agent 会有所不同。例如，Chrome、Firefox、Safari、IE 等不同浏览器会有不同的 User-Agent 字符串。

避免被识别为爬虫：网站可能会根据 User-Agent 来识别是否是爬虫程序。很多爬虫程序没有设置真实的 User-Agent，或者 User-Agent 字符串看起来像是一个自动化脚本（比如 Python 的 requests 库默认 User-Agent 是一个简单的字符串）。一些网站会使用这一点来检测并阻止爬虫请求。因此，为了模拟浏览器，爬虫通常会伪装成浏览器的 User-Agent，避免被网站识别为爬虫。

返回适配的内容：根据 User-Agent，服务器可以返回特定格式的内容。比如，移动设备和桌面设备通常会看到不同版本的网页，甚至不同的图片大小和样式。通过查看 User-Agent，服务器可以判断请求来自于手机、平板、桌面或其他设备，并返回不同的页面样式或功能。

分辨设备和浏览器版本： User-Agent 可以帮助服务器确定访问者的设备类型、操作系统及浏览器版本，从而优化响应内容。比如，某些页面可能会针对不同的操作系统（如 Windows、macOS、Linux）或不同版本的浏览器提供特定的网页布局或 JavaScript 功能。

可以看出，一些服务器会根据User-Agent来判断访问请求是不是来自人类或自动化脚本，可做一些反爬虫操作。我们从浏览器获取的请求信息中包含的User-Agent，表明了这段请求时来自浏览器，而非自动化脚本，因此，我们可以回答上面的问题：1.User-Agent一样是因为我们今天与昨天用的都是同一个浏览器访问，它代表了“该请求来自Edge浏览器”。2.无需担心它会发生变化，除非浏览器更新会更改这项数据，而这大概率是不会发生的。

代码实现

首先，先获取整个response的html数据，把它写在一个单独的文件里，（数据量太大，操作台无法查找相应的数据），有些导入的模块会在后面的代码中用到，这仅是完整代码的一部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


import requests
import re
from bs4 import BeautifulSoup
from urllib import response
import urllib.request
import json
url = "https://cn.bing.com/translator?ref=TThis&text=&from=zh-Hans&to=en"
header = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"}
response = requests.get(url,headers=header,data={})
response.raise_for_status()
html = response.text
with open("translator.html", "w", encoding="utf-8") as f:
 f.write(html)

获取到相应的HTML，直接搜索IG

现在，我们找到了这个数据，用正则表达式将数据获取，其中re.search方法是调用第三方库re

1

ig = re.search(r'IG:"(\w+)"',html).group(1) # 使用正则表达式在html文件中查找IG数据并获取

IID

我们用同样地办法查找IID的所在地并获取它

找到`IID`的所在

找到IID数据的所在，依然在translator请求响应中，这就好办了，因为该请求的完整相应已经被我们获取了，只要找到相应的位置即可。

刚刚获取的HTML文件中，你可以找到多个带有data-iid属性的<div>，因此，我们需要更加详细的信息来确认其位置，比如利用前面的id=" tta_outGDCont"，

代码实现

可以使用第三方库BeautifulSoup，获取html格式数据中特定的属性，比如data-iid

1
2
3
4


soup = BeautifulSoup(html, "html.parser")
dev_element = soup.find("div", id = "tta_outGDCont")
data_iid = dev_element.attrs["data-iid"]
print("data_iid:"+data_iid)

我们来解释一下soup = BeautifulSoup(html, "html.parser")这一段代码

1. BeautifulSoup

BeautifulSoup 是一个 Python 库，主要用于从 HTML 或 XML 文档中提取数据。它提供了许多方法来帮助你遍历、搜索和修改 HTML/XML 文档的内容。

2. html

html 是传入 BeautifulSoup 构造函数的参数，通常是一个包含 HTML 内容的字符串。它代表了待解析的 HTML 文档。可以是从文件读取的内容，或者是通过网络请求获取的 HTML 页面。

3. “html.parser”

"html.parser" 是 BeautifulSoup 的一个解析器（parser）。它告诉 BeautifulSoup 使用 Python 内建的 HTML 解析器来解析传入的 HTML 文档。这个解析器是一个快速且有效的解析工具，但对于一些特殊的 HTML，可能处理得不如其他第三方解析器（如 lxml 或 html5lib）精准。

"html.parser" 选项是 Python 默认的解析器，但如果你安装了 lxml 或 html5lib 等库，也可以指定其他解析器。例如：

"lxml"：使用 lxml 库的 HTML 解析器。

"html5lib"：使用 html5lib 库，它更宽容于不规范的 HTML 代码。

4. 最终效果

这行代码的作用是：通过 BeautifulSoup 库，将传入的 HTML 字符串 html 解析成一个 BeautifulSoup 对象，并指定使用内建的 html.parser 解析器。解析后的 soup 对象可以用来方便地操作和提取 HTML 内容。

剩下的代码看方法名称也很好理解它是做什么的

token与key

找到`token`与`key`的所在

我们用相同的办法，通过搜索框查找token的所在地，发现，这个信息同样存在于translator请求响应中：

如果你仔细一点，你会发现，token前面那串数字，就是我们下一个要找的key！真是得来全不费工夫，剩下的两个数据被我们一次性找到了，接下来就是获取它们。

代码实现

1
2
3
4


pattern = r'var params_AbusePreventionHelper = \[(\d+),"([^"]+)",\d+\];'
token = re.findall(pattern, html)
print("key:"+token[0][0])
print("token:"+token[0][1])

同样地，我们使用正则表达式，查找var params_AbusePreventionHelper后面的两个数据，放在token列表中。

小结

至此，我们找到了我们所需的全部数据，接下来只需要将IG与IID填进URL中，将token与key填进表单中，就可发送完整的请求，伪装成正常的浏览器请求了。

请求与获取相应

代码实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


url = "https://cn.bing.com/ttranslatev3?isVertical=1&&IG="+ig+"&IID="+data_iid
print(url)
header = {"user-agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"}
data = {"fromLang":"zh-Hans","to":"en","token":token[0][1],"key":token[0][0],"text":"今天的天气","tryFetchingGenderDebiasedTranslations":"true"}
print(data)
data = urllib.parse.urlencode(data).encode("utf-8")
req = urllib.request.Request(url, data, headers=header)
response = urllib.request.urlopen(req)
html = response.read().decode("utf-8")
target = json.loads(html)
print(target[0]['translations'][0]['text'])

根据上一篇文章的经验，以及本文上述的分析：

URL需要根据上文所获取的IG与IID进行动态变换
data数据，将我们上面获取的token与key分别放入字典中
对数据进行UTF-8编码转换格式
发送请求
获取响应并进行UTF-8解码
转换JSON格式
获取数据

如果将进行UTF-8解码后的数据完整打印出来，将会是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


[
 {
 "translations":[
 {
 "text":"Today's weather",
 "to":"en",
 "sentLen":{
 "srcSentLen":[
 5
 ],
 "transSentLen":[
 15
 ]
 }
 }
 ],
 "detectedLanguage":{
 "language":"zh-Hans"
 }
 },
 {
 "inputTransliteration":"jīntiān de tiānqì"
 }
]

我们要的就是translations列表下的第一个字典中text对应的value

完整代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


from csv import Error
from email.policy import HTTP
from tkinter import E
from urllib.error import URLError
import requests
import re
from bs4 import BeautifulSoup
from urllib import response
import urllib.request
import json


class Translation:
 def __init__(self,content):
 self.translating(content)

 def translating(content,lfrom,lto):
 if content == "":
 return "请输入内容"

 langfrom = {"自动检测":"auto-detect","中文":"zh-Hans","English":"en"}
 langto = {"中文":"zh-Hans","English":"en"}
 url = "https://cn.bing.com/translator?ref=TThis&text=&from=zh-Hans&to=en"
 header = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"}
 try:
 response = requests.get(url,headers=header,data={},timeout=5)
 except Exception as e:
 print(f"There are something wrong with the network: {e}")
 return "website is not reachable"
 html = response.text
 soup = BeautifulSoup(html, "html.parser")
 dev_element = soup.find("div", id = "tta_outGDCont")
 data_iid = dev_element.attrs["data-iid"]
 print("data_iid:"+data_iid)
 ig = re.search(r'IG:"(\w+)"',html).group(1)
 print("IG:"+ig)
 pattern = r'var params_AbusePreventionHelper = \[(\d+),"([^"]+)",\d+\];'
 token = re.findall(pattern, html)
 print("key:"+token[0][0])
 print("token:"+token[0][1])
 url = "https://cn.bing.com/ttranslatev3?isVertical=1&&IG="+ig+"&IID="+data_iid
 print(url)
 header = {"user-agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"}
 data = {"fromLang":langfrom[lfrom],"to":langto[lto],"token":token[0][1],"key":token[0][0],"text":content,"tryFetchingGenderDebiasedTranslations":"true"}
 print(data)
 data = urllib.parse.urlencode(data).encode("utf-8")
 try:
 req = urllib.request.Request(url, data, headers=header)
 response = urllib.request.urlopen(req)
 html = response.read().decode("utf-8")
 target = json.loads(html)
 except Exception as e:
 print(f'There are something wrong with the network: {e}')
 return "website is not reachable"
 try:
 print("translations:"+target[0]['translations'][0]['text'])
 except KeyError:
 print(target)
 return "something was wrong"
 return target[0]['translations'][0]['text']

结语

这次，我们完成了对微软翻译的完整爬虫，且可以完美多次长时间地运行，这个脚本功能已经完善，只是还没有嵌入到GUI程序中，下一篇文章，我们将会把这个脚本整理一下，放到脚本工具包中供翻译器调用，且会加装一些网络状况的判断。

如果你看到这里，说明你又变强了！希望你变得更强，感谢你的观看，共同进步！

基于PyQt开发的脚本集合包（八）

Thu, 07 Nov 2024 19:16:00 +0800

前言

本文虽然被归类于PyQt开发实战，但实际上并没有关于PyQt的相关知识，这篇文章着重基于上篇文章，讲述笔者在开发翻译器时如何做爬取微软翻译网站时的分析，如何获取到网站所需要的信息。这其中也是夹杂了许多笔者个人的猜想与运气才碰出来的，笔者对爬虫也没有做更深的学习，只有一些粗浅的理解，并结合这个项目一点一点摸出来的，可能有更专业的工具与更成体系的知识架构，笔者也要去学习，希望这篇文章对读者能起到一些帮助和启发。

本文从笔者第一次爬取开始讲起，第一次失败了，总结了失败的经验，第二次才爬取成功。

第一次爬取微软翻译

分析

在笔者进行爬虫的时候，首先先打开了浏览器自带的开发者工具查看网络数据，看看在翻译时客户端与服务器之间做了哪些交流

在排查的过程中，发现有一个名称叫做ttranslate...的包引起了笔者的注意，点进去发现这其中确实携带了笔者要翻译的信息

从上图中可以看到，包的负载中的表单数据中有一项Text，携带的数据刚好是我们输入的翻译内容你好。

打开预览可以看到更详细的信息

在这里可以发现：

这里有我们翻译之前的语种，即：zh-Hans，简体中文
翻译后的文本，保存在一个名为translations的数据中，text:Hello，这个数据就是我们要获取的数据，其实这就是对于翻译请求的响应，打开响应界面也是这一串信息

响应界面如下：

所以，本质上，笔者就是想要获得对于这个请求的响应，因此笔者的方法是模仿这个包的请求，读取它的响应，从而获得对应的翻译数据。

实践

因此根据爬虫的流程，笔者先获取了ttranslate的请求URL，即：

https://cn.bing.com/ttranslatev3?isVertical=1&&IG=94BF74DDDBA34ECB8B2CFB8D7960E4F9&IID=translator.5025

再获取了请求标头中的User-Agent，即：

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0

如下图所示：

获取URL是为了获取请求的目的地，获取User-Agent是为了让服务器认为我们是一个人，而不是脚本在自动操作（虽然真的是一个脚本），现在这两者已经获取，我们这段信息就有了身份。（虽然请求标头中还有许多其它的信息，但笔者也没搞懂有什么作用，索性也就没管）

接下来这既然是一个请求，那么我们就需要携带需要请求的消息，消息的格式是什么呢？在负载中可以找到，负载就是请求的内容，如下图所示：

显而易见的是，表单数据中携带了我们待翻译内容的语种，翻译结果的语种，以及翻译的数据。我们需要将这些信息放进我们的请求中。

信息收集完毕，开始编写代码（下面展示代码主题，读者需要注意这其中还调用了第三方关于爬虫的库，如报错，请pip install 响应的第三方库）

1
2
3
4
5
6
7
8
9


url = "https://cn.bing.com/ttranslatev3?isVertical=1&&IG=94BF74DDDBA34ECB8B2CFB8D7960E4F9&IID=translator.5025"
header = {"user-agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"}
data = {"fromLang":"zh-Hans","to":"en","text":text}
data = urllib.parse.urlencode(data).encode("utf-8")
req = urllib.request.Request(url, data, headers=header)
response = urllib.request.urlopen(req)
html = response.read().decode("utf-8")
target = json.loads(html)
print(target[0]['translations'][0]['text'])

以下，我们来逐行分析代码：

将刚刚得到的URL存放起来
将user-agent也存放起来，存放在header字典中
将我们请求的数据：翻译前的语种，翻译后的语种，文本也存放起来，存放在data字典中
将data进行utf-8加密，转换成响应的url请求格式
使用Request方法发送请求，参数为url,data,header
使用urlopen方法获取响应
将响应解码
将JSON格式的字符串解析成python对象，比如字典，列表等
获取这个target中关于translation列表下的字典的text对应的值

总结

以上，是笔者的第一次爬虫，一开始爬取的时候使用正常，可以正常的使用，但没过多久，翻译器无法使用，无故闪退，笔者开始debug，发现已经无法通过这个url发送请求了。

笔者开始整理，经过多次请求尝试和实验，发现url存在一些端倪：

https://cn.bing.com/ttranslatev3?isVertical=1&&IG=94BF74DDDBA34ECB8B2CFB8D7960E4F9&IID=translator.5025

我们再来看一下这个URL，可以发现，这URL本身就携带了一些信息，IG与IID，这两个数据在每次会话结束后，都会发生变化，也就是说，当一个会话结束后，笔者所记录的IG与IID就失效了，无法访问，因此，这一次爬虫并不成功，还需要继续改进，获取每次访问微软翻译时的IG和IID数据。

结语

总的来说，本文只是笔者在爬虫方向上的一次探索与学习，这是一次失败的尝试，不过可以看出，笔者在学习上的思路，笔者在学习时，喜欢在实践中发现问题并解决问题，因为理论与实践总是存在一定的差距，现实世界总是复杂且多变的。在实践中，你总会发现一些与理论有偏差或者相悖的地方，让你陷入迷茫，但是在实践中，你不会没有一点头绪，相反，在实践中，你有太多太多的方向去验证问题的本质，有时候往往是方向太多，你无法确定哪条路才能通向正确，你害怕做了无用功，害怕走错了方向，因此迟迟不敢动手，才导致了自己的踌躇不前。在现实世界中抽丝剥茧，也是一种学习，虽然笔者在这里也走错了路，离成功还有一段距离，但是走到这里，让笔者学会了如何看网络包，分析请求和响应，学会调用request库，以及最重要的找到了正确的道路，即：接下来，我们要想办法找到每一次IG和IID这两个数据如何变，在哪里变，如何获取到那个存放这两个数据的包。致敬技术，希望你变得更强！

基于PyQt开发的脚本集合包（七）

Thu, 07 Nov 2024 15:33:00 +0800

前言

上期文章我们讲了如何去实现一个UTF-8编码的转换器的构造以及代码实现。本期我们实现脚本集合包的第二个脚本（功能）：翻译器。目前，该翻译一起支持中译英，英译中，或自动检测翻译。翻译功能的实现本质上是通过爬虫技术去爬取网页实现的翻译功能，因此翻译功能需要联网才可进行。因此，在设计之初需要注意的是（虽然笔者并不是在设计之初就意识到会有这么多问题）：如何爬取一个网站，如何将需要翻译的内容上传给网站，是否需要判断当前状态是否联网，如何判断是否联网。如果处于断网状态如何处理……接下来两到三篇文章会详细讲述这些问题如何解决。

翻译器的UI布局

首先先看翻译器的UI布局

可以看到这个翻译器的主要框架分为上中下三个部分，垂直分布，因此，主布局是一个垂直布局，三个部分分别是：翻译语言选择，翻译文本框，快速翻译三个部分。

翻译语言选择：该部分由从左到右三个部分组成，水平布局，第一个下拉列表可选取待翻译语言的语种，包括：自动检测、中文、English三种，中间的组件是一个带有图标的按钮，可以转换左右下拉列表的语种，右边的下拉列表可选取翻译后的语种，包括：English、中文。
翻译文本框：该部分由从左到右三个部分组成，水平布局，第一个文本框是可读写文本框，可输入待翻译的内容，中间是一个按钮，点击按钮则开始翻译，右边文本框是一个只读文本框，在点击翻译按钮后，若翻译成功则会在该文本框中显示翻译后的内容。
快速翻译：快速翻译一个ListView，列表组件，其中存储了一个字典，显示对应的key，点击后会自动访问对应key的value，将value显示出来，无需联网，用于快速反应一些常用常翻译的内容。

代码解释

创建布局对象

根据上述UI的设计，我们可以创建对应的layout对象，并将子布局一次添加进主布局，主布局设置为widget的布局

1
2
3
4
5
6
7
8
9


 # create a horizontal layout
 layout = QVBoxLayout() # 主布局
 langlayout = QHBoxLayout() # 翻译语言选择的布局
 hlayout = QHBoxLayout() # 翻译文本框的布局
 listlayout = QVBoxLayout() # 快速翻译列表的布局
 layout.addLayout(langlayout) # 将三个子布局添加进主布局
 layout.addLayout(hlayout) # 将三个子布局添加进主布局
 layout.addLayout(listlayout) # 将三个子布局添加进主布局
 self.setLayout(layout) # 将layout设置为该翻译器widget的布局

翻译语言的选择与切换UI设计

该部分由两个comboBox（下拉列表）和一个PushButton（按钮）组成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


 # lang layout
 self.langfromcb = QComboBox(self) # 创建输入语言的下拉列表
 self.langfromcb.addItem("自动检测") # 往下拉列表中添加元素
 self.langfromcb.addItem("中文")
 self.langfromcb.addItem("English")
 self.langfromcb.setCurrentIndex(1) # 将下拉列表中的第二个元素（0为第一个）设置为默认选项

 self.langtocb = QComboBox(self) # 创建输出语言的下拉列表
 self.langtocb.addItems(['中文','English']) # 往下拉列表中添加元素
 self.langtocb.setCurrentIndex(1) # 将下拉列表中的第二个元素设置为默认选项

 self.exchangebtn = QPushButton(self) # 创建交换语种的按钮
 pixmap = QPixmap("_internal/res/img/exchange.ico") # 将图标添加进变量
 self.exchangebtn.setIcon(QIcon(pixmap)) # 为按钮设置图标
 self.exchangebtn.setIconSize(self.exchangebtn.sizeHint()) # 设置图标为自适应按钮大小
 self.exchangebtn.setToolTip("交换语言") # 为按钮设置提示泡泡
 self.exchangebtn.clicked.connect(self.tranasexchange) # 给按钮点击状态连接事件方法，该方法将调转输入与输出语种

 langlayout.addWidget(self.langfromcb) # 将三个组件都加入到第一个子布局中
 langlayout.addWidget(self.exchangebtn)
 langlayout.addWidget(self.langtocb)

在这一段代码值得注意的是：

这段代码展示了之前文章未出现的组件，即下拉列表（ComboBox）。
下拉列表有两种添加元素的方法，addItem()与addItems()，一个参数为单个元素，一个参数为list，可同时输入多个元素。
setCurrentIndex()方法可设置下拉列表的首选项，比如：下拉列表的顺序为：自动检测，中文，English，我想让中文成为默认选项，则可使用setCurrentIndex(1)来使得中文成为默认选项，因为python是从0开始算起的。
按钮可以添加图标，这个图标的地址开头是__internal，为什么使用这个作为最高级目录，请看往期内容基于PyQt开发的脚本集合包（三）第三节初始化应用程序部分，在窗口标签部分讲过相关内容。
按键的提示泡泡长这样，当鼠标放在按钮上，会弹出一个小框描述该按键的功能。

翻译文本框的UI设计

该部分是由两个文本框与一个按键组成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


 # input editor
 self.editor = QTextEdit(self) # 创建输入文本框
 self.editor.setPlaceholderText("翻译内容") # 设置文本框的背景内容
 hlayout.addWidget(self.editor) # 将输入文本框添加到子布局中
 TextEditStyle(self.editor) # 修改文本框的样式，作者创建的方法，非第三方库调用
 # translation button
 self.button = QPushButton("翻译",self) # 创建翻译按钮
 btnReleaseStyleA(self.button) # 修改按钮的样式，作者创建的方法，非第三方库调用
 self.button.clicked.connect(self.translating) # 按钮点击状态连接到translating事件方法
 hlayout.addWidget(self.button) # 将按钮添加到子布局中

 # output edit
 self.textedit = QTextEdit(self) # 创建输出文本框
 self.textedit.setPlaceholderText("翻译结果") # 设置文本框的背景内容
 self.textedit.setReadOnly(True) # 设置文本框为只读
 hlayout.addWidget(self.textedit) # 将文本框添加到子布局中
 TextEditStyle(self.textedit) # 修改文本框的样式，作者创建的方法，非第三方库调用

这段代码并没有什么需要特殊注意的地方，在之前的文章中我们已经用过多次了

快速翻译列表UI设计

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 # list layout
 self.workdist = {'快进':'forward','后退':'backward','暂停':'pause','停止':'stop',
 '播放':'play'}
 self.model = QStandardItemModel(0, 1) # 创建一个模型类，0行1列，即没有元素
 self.view = QListView(self) # 设置一个ListView对象
 self.view.setModel(self.model) # 设置ListView对象的模型为上面创建的模型
 for i in self.workdist.keys(): # 做一个for循环，循环从workdist中读取key
 item = QStandardItem(i) # 按顺序，将key设置为模型元素对象
 self.model.appendRow(item) # 将对象添加到模型中
 ListViewStyle(self.view) # 修改ListView的样式，作者创建的方法，非第三方库调用
 listlayout.addWidget(self.view) # 将ListView对象添加到子布局中
 self.view.clicked.connect(self.modelselected) # 将listview的点击状态连接到事件方法modelselected

这里新知识比较多，尤其是出现了一个陌生的控件QListView与一个模型类QStandardItemModel

QStandardItemModel的定义
在 PyQt 中，QStandardItemModel 是一个常用的模型类，它提供了一种标准的方式来存储和管理数据，尤其是用于与视图类（如 QListView、QTreeView 和 QTableView）配合使用。QStandardItemModel 是一种基于项（Item）模型的数据结构，它通过 QStandardItem 类来表示每个数据项。

QStandardItemModel 主要特点：
1. 基于项的模型：它使用 QStandardItem 来表示数据的每一项，QStandardItem 是存储数据和管理项状态的对象。
2. 支持树形和表格数据：通过 QStandardItemModel 可以管理数据，支持表格和树形结构。它可以通过层次结构来组织数据。
3. 与视图（View）绑定：QStandardItemModel 与 PyQt 中的视图类（如 QListView、QTreeView、QTableView）一起使用，模型控制数据，而视图负责数据的显示和交互。
QListView控件与QComboBox功能相似，但是用途，行为和样式差别较大，直接问大模型会给你长长的一条差别，但在这里，使用QListView的原因是它好看，可自定义样式，且不会收束成一个单个元素，而是完整地展示所有元素。

布局代码解释完了，接下来我们看一下实现交互功能的代码：

tranasexchange

1
2
3
4
5
6
7


 def tranasexchange(self):
 cba = self.langfromcb.currentText()
 cbb = self.langtocb.currentText()
 if cba == "自动检测":
 cba = "English"
 self.langfromcb.setCurrentText(cbb)
 self.langtocb.setCurrentText(cba)

这个代码逻辑很简单实际上就是一个获取两个QComboBox的当前选择内容，然后交换它，因为langto并没有自动检测这一选项，所以当langfrom选择的是自动检测，则切换成English。

translating

1
2
3
4
5
6
7
8


 def translating(self):
 print(self.langfromcb.currentText()," to ",self.langtocb.currentText())
 text = self.editor.toPlainText()
 tran = Translation.translating(text,self.langfromcb.currentText(),self.langtocb.currentText())
 if tran == "website is not reachable":
 MsgClass().show_HTTP_error("Website is not reachable")
 else:
 self.textedit.setText(tran)

首先将从什么语种翻译到什么语种打印到log面板上
text变量获取当前输入文本框中的文本内容
将text中的文本内容，当前选择的两个语种，一共3个参数传入Translation对象的translating方法中，该方法才是真正实现翻译功能的方法，该方法会返回一个字符串，tran获取这个字符串
该if的其实就是回应我们开头提出的问题：“需不需要判断网络问题”以及“如果网络异常该怎么办”，在一开始，笔者并没有处理这个异常，直到有一次笔者挂了clash访问GitHub时，无法访问翻译网站，结果导致程序闪退，所以，必须要判断网络问题，才做了这个if判断来抛出异常，使脚本在遇到网络问题时依然能够正常运行。
MsgClass是笔者写的一个消息处理类，主要功能是获取文本，制作一个弹窗，弹窗内容就是获取到的文本，在这里是Website is not reachable
如果网络没有问题，则不会将获取的文本输出到输出文本框中
当然这个网络异常逻辑设计并不完美，因为有可能翻译的内容恰恰是website is not reachable，这样也会导致UI这一部分误以为是网络异常，从而弹窗警告。更优解时返回两个变量，一个变量是翻译内容，一个变量是网站访问情况。if检测网站访问情况，如果非200，如404，则抛出弹窗警告。

modelselected

1
2
3
4


 def modelselected(self):
 print(self.view.currentIndex().data(),'to',self.workdist[self.view.currentIndex().data()])
 self.editor.setText(self.view.currentIndex().data())
 self.textedit.setText(self.workdist[self.view.currentIndex().data()])

如果是点击快速翻译中的某一项，则无需点击翻译按钮，直接完成翻译

在log面板上打印当前选择的元素以及元素所对应的value（元素为字典中的key）
将元素设置为输入文本框的内容
将元素对应的value设置为输出文本框的内容

本文要点

翻译器的主要UI布局其实是模仿目前市面上大多数的翻译器设计的，主要是模仿微软翻译，即：搜索 Microsoft Translator - 从英语翻译到中文 (简体)。其实，该翻译器的实现，主要也是爬取了微软翻译，翻译器模仿成用户，向微软翻译发送翻译文本，并获取返回的response，拿到翻译后的结果。之所以不爬取有道翻译，是因为有道翻译对爬虫限制很高，现在甚至无法打开开发者工具（如果在有道翻译页面强行打开开发者工具，会导致闪退该页面）。
在这个页面的UI设计中，我们加入了许多新玩意儿，比如ListView，模型类QStandardItemModel，QComboBox，等等有趣的东西，想使用但却没有实际例子模仿的小伙伴可以借鉴参考。
在本文中我们回答了开头的五个问题中的两个，“是否需要判断当前状态是否联网”答案是：需要判断当前状态是否联网，如果不加以判断，当处于断网时，爬虫无法正常爬取网页，会抛出Error或Exception，如果处理，则会导致程序闪退。
“如果处于断网状态如何处理”，答案是，当判断出断网状态时，会抛出弹窗警告，弹窗警告的设计是笔者自做，后续系列更新会介绍。

基于PyQt开发的脚本集合包（六）

Mon, 04 Nov 2024 21:36:00 +0800

方法在工程中的位置

这一小节需要结合前面的基于PyQt开发的脚本集合包（二）内容来看，在那一篇文章中，我们讲到，我们讲主界面，功能UI界面，以及实现功能本身的方法分别放在了不同的地方以方便我们维护，此方法属于功能的实现，因此与其它脚本功能一同放在了tools目录下，如果要调用该功能，则需要使用import导入模块。

代码解释

convertor模块中并没有类，只有一个方法，即convertor方法，它接受一个字符串参数，并将字符串进行编码，处理成UTF-8格式，输出十六进制数以及十六进制数的个数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


def convertor(s):
 res = ''
 # 将字符串s编码为UTF-8格式的字节串
 strlen = len(s)
 for i in range(strlen):
 # 将字节串转换为十六进制表示，同时移除b''标记并替换\\x为0x
 hexstr = ''.join(f'{byte:02x}' for byte in s[i].encode("UTF-8"))
 hexstr = hexstr.upper() # 可选：转换为大写
 # 添加空格使得输出更易于阅读
 hexstr_space = ', 0x'.join(hexstr[i:i + 2] for i in range(0, len(hexstr), 2))
 hexstr_space = '0x'+hexstr_space
 res = res + hexstr_space + ', '
 res = res[:-2]
 print(res)
 return res,res.count('0x')

以下逐行解释代码：

初始化res字符串变量，
获取传入的参数s字符串的长度，并传给strlen
for循环遍历字符串中的每一个字符
s[i].encode("UTF-8")将字符编码为UTF-8字节串
for byte in ...是一个生成器表达式，它遍历编码后的字节串，每个byte表示UTF-8编码中的每一个字节
f'{byte:02x}'将每个字节转换为两位的十六进制字符串，0表示如果十六进制不足两位，则以0补足，2表示宽度位两位，x表示以十六进制格式输出，比如：如果byte的值为255，则会生成’ff’，如果byte的值为7，则会生成'07'
''.join(...)，join方法将生成器表达式的所有结果连成一个字符串，即格式化操作，例如：一个字符编码为b'\xe4\xb8\xad'，经过格式化后将变成'e4b8ad'
upper方法将输出的字符串中所有小写转换成大写
又一个join方法，将hexstr一个字符一个字符拆开，每个两个字符中间便加入, 0x，经过上一个join方法，这次经过格式化操作后，e4b8ad将会变成E4, 0xB8, 0xAD, 0x
在字符串最前面加上0x，变成：0xE4, 0xB8, 0xAD, 0x
删除最后3个字符（-1是最后一个，-2是倒数第二个，但是[]读内容的规则：前面读，后面不读，也就是虽然是最后一位是倒数第二，但实际上倒数第二不读，只读到倒数第三）
打印res结果
返回结果以及0x的计数（通过计算0x来计算有多少个十六进制数）

本文要点

本文中展示了，方法在工程中的位置，以及如何在工作区UI对象中导入该模块
详细解释了convertor方法如何实现字符串转UTF-8格式
其中有许多用法值得我们详细学习，比如join方法的使用，f'{byte:02x}'将每个字节转换成十六进制数，upper方法的使用，[]的读取范围的规则等

基于PyQt开发的脚本集合包（五）

Mon, 04 Nov 2024 19:29:00 +0800

UTF-8编码器

UTF-8（8位元，Universal Character Set/Unicode Transformation Format）是针对Unicode的一种可变长度字符编码。它可以用来表示Unicode标准中的任何字符，而且其编码中的第一个字节仍与ASCII相容，使得原来处理ASCII字符的软件无需或只进行少部分修改后，便可继续使用。

比如：在蓝牙领域中，主机与从机自身携带的一些信息如蓝牙名称等，就是由UTF-8编码成十六进制字符串后进行传输，在进行蓝牙开发时，就会经常用到UTF-8编码，因此作者也是自做了一个UTF-8编码器集成到自己的脚本工具包中方便使用。

UI设计

首先看成品，这个UTF-8编码器的工作区一共有几个部分组成：

编码内容：是读写文本框，在此文本框中，可输入数字，符号，中文，英文等各种可被UTF-8编码的字符串，该文本框为默认形式，即可读可写。
编码结果：是只读文本框，在此文本框中，会显示编码完成后的结果，即十六进制数字组，例如：PyQt5编码后，编码结果会显示0x50, 0x79, 0x51, 0x74, 0x35，此文本框只允许读，复制等操作，不允许改写其中的内容。
字符数：也是只读文本框，在此文本框中，会显示编码结果的字符数，例如：PyQt5编码后，编码结果为5个十六进制数，字符数就为5，值得注意的是，字符数并不是与编码内容的字符串的长度一定相等，如果你的编码内容中含有中文，1个中文则会有3个十六进制数表示。
按钮：按钮连接了一个方法，在按钮被点击时触发方法，读取编码内容中的字符串，进行处理，然后再将结果输出再编码结果与字符数中。

功能UI的存放目录

在PyQt的第二篇文章（基于PyQt开发的脚本集合包（二））中我们讲到，实现不同功能的UI类是存放在一个相同的目录下，这样方便我们维护，也正是因为功能区的UI放在一个名为Classes的目录下，PrimeWindow不在该目录下。

因此PrimeWindow想要调用，实现UTF-8编码器的UI界面，需要使用import。

这表示：导入Classes目录下的ConvertorClass模块，并重命名为ConvertorClass。

可以回到第四篇文章基于PyQt开发的脚本集合包（四）查看PrimeWindow如何使用这个模块的（在create_stack方法中）。

代码解释

def init

先看初始化代码，也是这个UTF-8对象的入口（这个UTF-8编码器是写在另一个目录下的一个类，上一篇文章中讲到的PrimeWindow就是调用了这个UTF-8编码器类，创建了一个编码器对象，这个类继承于Qwidget，因此这个编码器对象可以被看作是一个Qwidget来使用。）

PS：如果对Qwidget这个概念有些模糊的话请看这里（如果熟悉了PyQt的基本知识请继续往下看），Qwidget本质上是一个组件，和按钮，文本框一样，只不过这个组件中可以放其它的组件，你可以把Qwidget想象成一个容器，这个容器装了许多东西，打包起来，然后再放到另一个容器中，像套娃一样。我们这里就是将上面说的三个文本框与按钮排列好放在一个名为Convertor的Qwidget容器中，然后打包成一个类，可供其它更大的Qwidget（比如PrimeWindow）调用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


 def __init__(self):
 super().__init__()

 self.layout = QVBoxLayout() # 设置编码器的主布局为垂直布局VBox
 self.inputlayout = QHBoxLayout() # 设置水平的输入布局，即编码内容（由“编码内容”这四个字的标签与文本框水平布局构成）
 self.outputlayout = QHBoxLayout() # 设置水平的输出布局，即编码结果
 self.countlayout = QHBoxLayout() # 设置水平的计数布局，即字符数
 self.layout.addLayout(self.inputlayout) # 将三个布局以此添加进主布局中
 self.layout.addLayout(self.outputlayout) # 依次添加会按顺序从上往下排列
 self.layout.addLayout(self.countlayout) # 总的来说是三个小布局垂直分布，每个小布局中的两个组件水平分布

 self.inputlable = QLabel("编码内容",self) # 创建“编码内容”这个四个字的标签
 self.inputlayout.addWidget(self.inputlable) # 加入到输入布局中，从左到右排列
 self.inputedior = QTextEdit("输入文本",self) # 创建输入文本框
 TextEditStyle(self.inputedior) # 设置文本框的样式，该方法为作者自写，非第三方库调用
 self.inputlayout.addWidget(self.inputedior) # 将文本框添加到输入布局中

 convertbtn = QPushButton("UTF-8编码",self) # 创建按钮，按钮上的文字为“UTF-8编码”
 btnReleaseStyleA(convertbtn) # 设置按钮弹起状态的样式，该方法为作者自写，非第三方库调用
 convertbtn.clicked.connect(self.converting) # 将按钮的点击状态连接到converting方法上，一旦检测到按钮被点击，则调用该方法
 convertbtn.clicked.connect(self.counting) # 同理，将按钮的点击状态连接到counting方法上，一旦检查测到按钮被点击，则调用该方法
 self.layout.addWidget(convertbtn) # 将按钮添加到主布局中，因为上面已经添加了三个小布局，因此按钮在布局最下方

 self.outputlable = QLabel("编码结果",self) # 创建“编码结果”这四个字的标签
 self.outputlayout.addWidget(self.outputlable) # 添加到输出布局中
 self.outputedit = QTextEdit("输出文本",self) # 创建输出文本框
 self.outputedit.setReadOnly(True) # 将文本框设置为只读模式
 TextEditStyle(self.outputedit) # 设置文本框的样式，作者自写，非第三方库嗲用
 self.outputlayout.addWidget(self.outputedit) # 将文本框添加到输出布局中

 self.countlable = QLabel("字符数：",self) # 与上相同
 self.countlayout.addWidget(self.countlable)
 self.countedit = QTextEdit("字符数",self)
 self.countedit.setReadOnly(True)
 TextEditStyle(self.countedit)
 self.countlayout.addWidget(self.countedit)
 # ********************** 已删，不好看 **********************
 # 删除edit边框
 # self.countedit.setFrameShape(QFrame.NoFrame)
 # # 删除edit背景
 # self.countedit.setStyleSheet("background-color: transparent;")
 # ********************** 已删，不好看 **********************
 self.setLayout(self.layout) # 将主布局设置为Qwidget的布局

def converting

converting方法是主要实现UTF-8编码的方法的入口，它并不直接完成该任务，而是获取输入文本框的数据，然后传参给真正的编码方法。

1
2
3
4


 def converting(self):
 self.text = self.inputedior.toPlainText()
 self.res,self.count = convertor(self.text)
 self.outputedit.setText(self.res)

下面逐行解释代码：

从输入文本框中获取文本内容，在PyQt中，toPlainText是QTextRdit控件的一个方法，用于获取文本框中的所有内容，并返回一个字符串，这与toHtml()不同，后者返回的是HTML格式的文本。
调用convertor这个外部方法，传入的参数就是文本框的内容（字符串），并获取返回结果（两个参数，一个是结果，一个是字符串数）。
将结果设置为输出框的文本。

值得注意的是，这里count变量被形容为self，这也就是说，在同一实例（对象）中，实例中的各个方法（被传入self），都可以调用这个count变量。

def counting

counting方法的作用就是将上面得到的count设置为计数文本框中的内容。

1
2


 def counting(self):
 self.countedit.setText(str(self.count))

为什么要舍近求远做这样一个操作呢，是为了提醒我：

一个按钮的某一状态连接多个事件是可行的。
使用setText方法对某一文本框填入数据时，参数必须为字符串，如果非字符串的参数，必须使用str()方法转为字符串。
更深入了解self，可支持某一变量在其它方法间共用。

本文要点

本文中展示了，之前文章中铺垫的，功能区的用法。本质上就是功能区是PrimeWindow这个大的容器（Qwidget）专门空出来的一块地方，可以用来放其它的小的容器（Qwidget），其它的小的容器以对象（实例）的方式被创建，然后存放在抽屉（stack）中，这样我们在切换抽屉时，就是在切换小的容器，实现了大容器不变的情况下，大容器中的某一块区域可以灵活变化。
__init__方法是这个对象的入口（创建时被首先调用的函数），当对象被创建时，则会自动地进行初始化，完成整个编译器UI的创建和布局。初始化方法的代码解释写在了代码块中，因为代码较长，如果写出来的话篇幅太大，但是不写的话在CSDN和个人博客中都比较难阅读（无法自动换行），因此建议大家复制下来，贴在VScode中或自己的Typora中看，这样方便一点。
按钮连接的方法是使用xxxbtn.clicked.connect(xxxfunction)，该方法旨在某按键被click（点击）时，调用xxxfunction方法，且可以连接多个方法。
converting方法实际上是一个处理API的方法，负责传参与接收结果，convertor方法在下一篇文章中会介绍。
counting方法可以被整合到converting方法中，不过整个项目是作者的一个学习过程与心得，这样写是为了方便展示一些特性。
如果本文对你有所帮助，请记得给作者的CSDN点赞收藏QAQ，多多逛逛和订阅作者的个人博客，有什么问题或错误请联系作者的CSDN或发送到邮件中，祝大家生活愉快，变得更强！

基于PyQt开发的脚本集合包（四）

Fri, 01 Nov 2024 10:43:00 +0800

PyQt主窗口框架设计(QWidget)

PrimeWindow.py的主要作用是绘制主窗口，在主窗口中：

最左边是各种功能组件的入口，比如：翻译器，UTF-8转换，图像处理等。
按下左边的按键，则会切换功能区，切换功能并非重新开一个窗口，而是切换中间部分，这里主要是采用stack的原理
最右边是日志打印区，通过重定向的方法，把打印在操作台的内容打印到这个窗口上，这样方便开发人员debug

4.1 import部分

1
2
3
4
5
6
7
8


import Classes.TranslatorClass as TranslatorClass
import Classes.ConvertorClass as ConvertorClass
import Classes.AudioProcessClass as AudioProcessClass
import Classes.AudiocodecClass as AudiocodecClass
import Classes.AudioPlayerClass as AudioPlayerClass
import Classes.ImgProcessClass as ImgProcessClass
from component.btnStyle import *
from component.editStyle import *

这些引用均来自作者自己的代码，分别保存在Classes目录下和component目录下，从这些目录下import不同的类或方法供PrimeWindow调用。

Classes中的各种类，如TranslatorClass，保存着翻译功能的功能区UI结构：翻译按钮，翻译内容输入框以及翻译结果展示框等，以及各组件的摆放位置。

component中的各种方法，如btnStyle，该文件中有按钮按下的样式，按钮抬起的样式等，只需在点击按钮时调用该方法即可改变按钮样式。

4.2 重定向操作台输出

重定向操作台输出需要调用一些系统方法

1
2
3
4
5
6
7


 current_directory = os.getcwd() # 获取当前工作目录，并将其存储在current_directory中。
 self.original_stdout = sys.stdout # 将当前的标准输出（操作台）保存到self.original_stdout中，这样可以在将来恢复标准输出
 self.output_stream = io.StringIO() # 创建一个StringIO对象，这个对象像一个文件，可以在内存中操作字符串，之后的标准输入输出将写入这个对象
 sys.stdout = self.output_stream # 将标准输出重定向到刚才创建的StringIO对象self.output_stream。这样，所有通过print语句输出的信息都将储存在output_stream中，而不是打印到操作台
 self.timer = QTimer() # 创建一个定时器对象，用于定期触发某些事件
 self.timer.timeout.connect(self.updateOutput) # 将定时器的信号连接到self.updateOutput方法上，当定时器达到超时时间时则会调用该方法
 self.timer.start(1000) # 设置定时器的超时时间为1000ms即1s

以上实现的是：重定向操作台的输出，开启定时器，每1s后，将原本pirnt方法打印到操作台的字符串储存起来，并调用updateOutput方法

以下是代码逐行分析：

获取当前工作目录，并将其存储在current_directory中
将当前的标准输出（操作台）保存到self.original_stdout中，这样可以在将来恢复标准输出
创建一个StringIO对象，这个对象像一个文件，可以在内存中操作字符串，之后的标准输入输出将写入这个对象
将标准输出重定向到刚才创建的StringIO对象self.output_stream。这样，所有通过print语句输出的信息都将储存在output_stream中，而不是打印到操作台
创建一个定时器对象，用于定期触发某些事件
将定时器的信号连接到self.updateOutput方法上，当定时器达到超时时间时则会调用该方法
设置定时器的超时时间为1000ms即1s

updateOutput方法：

1
2
3
4
5
6
7
8
9


 def updateOutput(self):
 output = self.output_stream.getvalue() # 从output_stream中获取字符串
 if output: # 如果其中有字符串的话
 cursor = self.consoleedit.textCursor() # 获取日志打印文本编辑控件的当前光标，方便在特定的位置插入文本
 cursor.movePosition(QTextCursor.End) # 将光标移动至结尾，以便现有文本插入新的输出内容
 cursor.insertText(output) # 将内容添加到日志打印文本编辑控件中
 self.consoleedit.setTextCursor(cursor) # 更新光标位置为刚刚移动的光标，这确保了后续的输入或操作将从正确的位置开始
 self.consoleedit.ensureCursorVisible() # 确保光标在文本编辑器中可见，特别是光标在底部时，防止用户无法看到最新的插入内容，尤其是文本框不够大时
 self.output_stream.truncate(0) # 清空output_stream中的内容，将其内容截断为0，使得下一轮输出时不会将之前的内容重复添加

通过这个方法，即可将打印的内容输出到日志打印区中。并每1秒就检查一次是否有新的内容需要输出

因为是利用定时器每1秒检查一次是否有新的输出内容，所以输出并不是实时进行的，如你需要更精确的日志打印，则调小定时器的超时时间，但请注意，定时器的超时时间越短，定时器就会越频繁地调用updateOutput方法，即使什么新内容也没有。如果你需要做一些复杂且精密的操作，则可能需要考虑时间与空间开销的问题。

以下是代码逐行分析：

从output_stream中获取字符串
如果其中有字符串的话
获取日志打印文本编辑控件的当前光标，方便在特定的位置插入文本
将光标移动至结尾，以便现有文本插入新的输出内容
将内容添加到日志打印文本编辑控件中
更新光标位置为刚刚移动的光标，这确保了后续的输入或操作将从正确的位置开始
确保光标在文本编辑器中可见，特别是光标在底部时，防止用户无法看到最新的插入内容，尤其是文本框不够大时
清空output_stream中的内容，将其内容截断为0，使得下一轮输出时不会将之前的内容重复添加

4.3 stackLayout 切换功能

在PyQt中，QStackLayout是用于在同一位置上堆叠多个小组件的布局管理器，允许根据需要在它们之间进行切换，这对实现标签页或动态内容展示非常有用

1
2
3
4
5
6


 def create_stack(self):

 # create a stack layout
 self.stacklayout = QStackedLayout()
 convertor = ConvertorClass.Wconvertor()
 self.stacklayout.addWidget(convertor)

创建stacklayout
把功能UI实现的对象添加在stacklayout中

1
2
3
4
5
6
7


 # set the convertor buttons
 self.UTF8ConvertorBtn = QPushButton("UTF-8 转换") # 创建按钮对象
 btnReleaseStyleA(self.UTF8ConvertorBtn) # 修改按钮样式，该方法为作者创建，并非第三方库调用
 self.UTF8ConvertorBtn.clicked.connect(self.Cbtn_press_clicked) # 为按钮连接触发事件，该事件会切换stack
 # add the buttons to the layout
 self.btnlayout.addWidget(self.UTF8ConvertorBtn) # 将按钮添加到功能按钮区布局
 updateButtonStyle(self,self.UTF8ConvertorBtn) # 更新按钮样式，该方法为作者创建，并非第三方库调用

UTF8ConvertorBtn按钮连接上了Cbtn_press_clicked方法，表示当该按钮被按下时，则调用Cbtn_press_clicked方法。同时我对按钮的样式做了修改，使用方法btnReleaseStyleA，因为要对按钮做批量相同的修改，因此集成到一个方法中去调用是常见的编程思想。

1
2
3


 def Cbtn_press_clicked(self):
 updateButtonStyle(self,self.UTF8ConvertorBtn) # 更新按钮样式，该方法为作者创建，非第三方库调用
 self.stacklayout.setCurrentIndex(0) # 将当前stack布局设置为第一个抽屉

setCurrentIndex方法的意思是，stacklayout所占据的这一片区域，可以随意切换成被它add了的widget，它就像一个抽屉一样，抽屉的大小固定，但是这个固定的大小所展示的内容是由你抽出第几层决定。就比如参数为0，则抽出的是第1个抽屉，这个抽屉是一个widget，这个widget可以套一个layout，其中放各种各样的组件。同理，参数为1,则表示抽出第2个抽屉，则stacklayout所占据的这一片区域就会切换成第2个抽屉的样子。

4.4 UI初始化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


 def initUI(self):
 #---------------- create Layout we needed ----------------------------
 self.Mainlayout = QHBoxLayout() # 主窗口
 self.Primarylayout = QVBoxLayout() # 功能区布局
 self.btnlayout = QVBoxLayout() # 功能按钮区布局
 #---------------- create Layout we needed ----------------------------


 #---------------- there has more btn but unshowing -------------------
 # set the convertor buttons
 self.UTF8ConvertorBtn = QPushButton("UTF-8 转换") # 创建按钮对象
 btnReleaseStyleA(self.UTF8ConvertorBtn) # 修改按钮样式，该方法为作者创建，并非第三方库调用
 self.UTF8ConvertorBtn.clicked.connect(self.Cbtn_press_clicked) # 为按钮连接触发事件，该事件会切换stack
 # add the buttons to the layout
 self.btnlayout.addWidget(self.UTF8ConvertorBtn) # 将按钮添加到功能按钮区布局
 updateButtonStyle(self,self.UTF8ConvertorBtn) # 更新按钮样式，该方法为作者创建，并非第三方库调用
 #---------------- there has more btn but unshowing -------------------
 self.btnlayout.setAlignment(Qt.AlignTop) # 调整按钮区的各组件对齐方式为向上对齐，而非均匀分布


 #----------------- put the stack in function area --------------------
 widget = QWidget() # 创建一个widget，用于存放stack布局
 widget.setLayout(self.stacklayout) # 将stack布局放到widget中
 self.Primarylayout.addWidget(widget) # 将widget放到功能区布局中，至此stack在功能区中进行切换
 #----------------- put the stack in function area --------------------
 #---------------------- create log area ------------------------------
 self.Consolelayout = QVBoxLayout() # 创建日志区布局
 self.consoleedit = QTextEdit() # 创建日志编辑文本框
 self.consoleedit.setReadOnly(True) # 文本框设置为只读
 TextEditStyle(self.consoleedit) # 修改文本框样式， 该方法为作者创建，并非第三方库调用
 self.consoleedit.verticalScrollBar().setPageStep(100) # 修改滚动条步长
 self.Consolelayout.addWidget(self.consoleedit) # 添加文本框到日志区布局中
 #---------------------- create log area ------------------------------

 #------------------ put the layouts in main layout -------------------
 self.Mainlayout.addLayout(self.btnlayout,stretch=1) # 将按钮布局添加到主布局中
 self.Vline = QFrame(self) # 添加细线 将按钮区与功能区分隔开
 self.Vline.setFrameShape(QFrame.VLine) # 优化细线
 self.Vline.setFrameShadow(QFrame.Raised) # 使细线具有凸起的立体感
 self.Vline.setLineWidth(3) # 设置细线外部粗细
 self.Vline.setMidLineWidth(1) # 设置细线内部粗细
 self.Mainlayout.addWidget(self.Vline) # 将细线添加至主布局
 self.Mainlayout.addLayout(self.Primarylayout,stretch=4) # 将功能区添加至主布局中
 self.Mainlayout.addLayout(self.Consolelayout,stretch=2) # 将日志区添加至主布局中
 # add the layout to the window
 self.setLayout(self.Mainlayout) # 将主窗口的布局设置为主布局
 #------------------ put the layouts in main layout -------------------

4.5 结语

到目前为止，我们脚本工具集合包已经具备了初步的大致框架，三大区块已经被划分出来了，接下来的工作将重点放在要开发哪些功能，如何实现这些功能，以及这些功能的UI页面布局。这个系列将会==持续更新==，动手能力强的小伙伴可以根据路线自己实操一遍，后续我也会将完整代码开源带GitHub上（等系类差不多结束的时候），同时系列文章也会同步更新到我的CSDN博客中，如果本系列真的帮助到你，请关注本频道，并给我的CSDN==点赞收藏==QAQ，感激不尽！

如有任何疑问，欢迎私信我的CSDN或发邮件到707973090@qq.com，在我看到时会第一时间回复！

基于PyQt开发的脚本集合包（三）

Fri, 01 Nov 2024 10:40:00 +0800

PyQt程序入口（QMainWindow）

main.py是程序的入口，程序最开始运行的文件，在这个文件中，需要完成以下几件事：

创建一个MainWindow（主窗口）
设置主窗口的标题，图标
设置窗口的主体（centralWidget）
设置窗口的状态栏
创建workspaces目录
运行窗口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


import sys
import os
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *

import PrimeWindow

class MainWindow(QMainWindow):
 def __init__(self):
 super().__init__()
 self.setWindowTitle("Script Tools")
 self.setWindowIcon(QIcon("_internal/res/icon/icon.ico"))
 centralWidget = PrimeWindow.PrimeWindow()
 self.setCentralWidget(centralWidget)
 self.addStatusBar()


 def addStatusBar(self):
 self.statusBar = QStatusBar()
 self.statusWidget = QWidget()
 self.statusLayout = QHBoxLayout()
 self.copyrightlable = QLabel("© Author: LyricalRover. All rights reserved.")
 self.versionlable = QLabel("Last updated: 2024-10-18. Version: 1.3.1")
 self.statusLayout.addWidget(self.copyrightlable)
 self.statusLayout.addStretch()
 self.statusLayout.addWidget(self.versionlable)
 self.statusWidget.setLayout(self.statusLayout)
 self.statusBar.addWidget(self.statusWidget)
 self.setStatusBar(self.statusBar)



if __name__ == "__main__":
 app = QApplication(sys.argv)
 w = MainWindow()
 if not os.path.exists("workspaces"):
 os.makedirs("workspaces")
 w.show()
 app.exec()

最开始进入的地方是：if__name__ == “_main_”:

app = QApplication(sys.argv)初始化应用程序对象

1. QApplication 类

QApplication 是 Qt 应用程序的主类，负责管理应用程序的控制流和主要设置。

它处理应用程序的主事件循环，并为 GUI 元素提供必要的支持。

每个使用 Qt 的应用程序通常需要一个 QApplication 实例。

2. sys.argv 的作用

sys.argv 是一个列表，包含命令行参数。这些参数是在运行 Python 脚本时传递的。

QApplication 可以使用这些参数来配置应用程序的行为，例如窗口大小、样式等。

3. 初始化应用程序

通过 app = QApplication(sys.argv)，你完成了以下几个步骤：

创建应用程序对象：这行代码创建了一个 QApplication 的实例，并将命令行参数传递给它。

设置事件循环：这个实例负责管理 GUI 的事件循环，使得应用程序能够响应用户输入和事件（例如鼠标点击、键盘输入等）。

为应用程序提供上下文：QApplication 提供了关于应用程序的信息，例如样式、主题、字体等。

创建MainWindow对象，即运行上面的class中的代码

def __init__中，设置窗口的标题，设置窗口的图标，在这里可以看到，设置图标的路径是：_internal/res/icon/icon.ico，但我们并没有创建这个__internal的目录，回顾环境配置中pyinstaller部分的讲解：“pyinstaller在v6.0版本以后，数据将被移动到__internal目录下”，也就是说，如果我们打包程序形成exe文件后，想要文件能够正确找到icon的地址，则必须在你写的地址前加上__internal目录，配合上打包时的参数,-add-data "icon.ico;__internal/res/icon/icon.ico"，就可以在打包后显示正常的图标。

1

centralWidget = PrimeWindow.PrimeWindow()

上面的代码是创建一个UI主体，该主体是PrimeWindow对象，这个类在PrimeWindow.py中，这个主体内具体是怎样的后面会讲到。

addStatusBar的结构如下图所示：

左右分别是两个label的Widget，分别装了两条信息，中间用addStretch弹簧将两个label分压向两侧。

理想很丰满，现实很骨感，实际上并没有呈现出这样一个操作，我猜测应该是有另一个东西阻碍了StatusBar，并没有完整占据整个窗口的下方，也就是说，StatusBar本身被压缩了，导致versionlabel并没有被压向窗口主体的右侧。但具体原因尚不明朗。

还有一点值得注意的是：

我在引入第三方库的时候因为偷懒使用了“*”，即：from PyQt5.QtWidgets import *等。

建议使用了什么就引入import什么，而不是为了图方便而直接使用“*”，理由如下：

python模块的导入实际上是通过import来进行导入的，一个模块一旦被导入，后续的导入操作则直接从缓存中读出，而不会重复导入，这就说明，在初次操作时，需要加载导入内容，如果使用“*”，初次导入的时间开销会更多一些，但后续的性能差别并不明显。
由于import *会导入所有的公共成员，因此它可能会占用更多的内存，因此空间开销会更大。
使用更明确的导入方式，会有助于代码的可读性，避免不必要的模块加载，减少潜在的时间和空间开销，同时较少命名冲突的风险，这种情况在大型项目中更为明显。

基于PyQt开发的脚本集合包（二）

Fri, 01 Nov 2024 10:36:00 +0800

布局

2.1 UI页面布局

整体框架分为分为三个部分，垂直分布。

第一个部分为功能选择按钮（如UTF-8转换，翻译器等）
第二部分为功能区，即对应功能输入，输出展示区
第三部分为后台区，显示对应的后台信息（本质上是将终端输出的print重定向至这块区域，方便调试以及使用）

除此之外，整体的下方状态信息栏中有版本信息

整体布局如下图所示：

tips：

这个界面是直接在vscode中运行时所展示的，因此图标以及部分按钮并未完全列装（不保证debug与打包一致的原因较为复杂，与pyinstaller的版本有关，后续内容会解释），图标列装后如下所示：

2.2 工程布局

在创作自己的程序前（如果是较大的程序），最好需要规划一下自己的工程结构，用多个不同的目录保存不同的资源，如图像，文本，代码等，而代码中，实现不同功能的subprograms（子程序）也可以再细分在不同的目录中，尤其是可以多个subprogram（子程序）反复调用的subprograms（子程序）或scripts（脚本）。

我的工程布局意识也是在这个项目中不断完善的，还有一些不足和错误的地方也在不断更新中。

一级目录

MyScriptTools目录是包目录，为了方便管理我们需要用到的各种包文件，需要在项目开始时便创建好该项目python运行的虚拟环境（虚拟环境具体的创建流程看前文）。创建完成后，使用pip包管理器下载的所有包都会保存在这个包目录中。（因为我的虚拟环境名字叫MyScriptTools，因此包目录的名字也叫MyScriptTools）
src是存放代码的位置，所有的代码都存放在这个目录下
workspaces目录是运行时创建的保存文件目录，因为我的项目中，有一些功能或脚本会产生新的文件，我希望它们被保存在一个统一的空间，看起来不会太过混乱，因此专门设计了这一个功能：在程序运行时，创建一个workspaces目录，以后若产生新的文件，统一保存在workspaces目录下
BingTranslator.py与test.py是两个测试脚本，目前已经失去了作用

src目录

Classes：该目录下存放着各种功能的功能区UI类，error类等，如TranslatorClass.py为翻译功能的UI设计，包括按钮，文本框的布局等
component：该目录下存放着修改组件样式的方法，如editStyle.py文件中存放着修改QLineEdit样式的方法以及修改QTextEdit样式的方法。这样如果有多个QLineEdit组件需要修改样式时，只需要调用其中的方法即可。
dist：该目录是使用pyinstaller将程序打包成exe可执行文件时生成的，exe可执行文件存放在其中
res：该目录下存放着需要使用的图片，图标等资源文件
tools：该目录下存放着脚本以及功能的实现，如：实现翻译的功能方法存放在tools目录下的translation.py文件中，Classes目录下的TranslatorClass.py文件中会调用translation.py文件来实现功能
xxx.spec：该文件是如果打包时使用了–onefile参数，即打包生成一个单独的exe文件，则会产生该文件，该文件记录了一些打包时需要关注的信息
icon.ico：图标文件，可要可不要，如果不要，在打包时想要生成exe文件的图标时需要指定图标的路径，我懒得指定路径，只想填个名字，就把图标放在与main.py同一目录下
main.py：该文件时程序的入口，与C程序的main相同。打包时需要指定程序入口，即该文件
PrimeWindow.py：主UI框架，即主窗口，上面Classes中的UI仅为功能区UI，属于主窗口的三部分之一

2.3 布局思想

我的布局思想是在不断碰壁的过程中自己摸索出来的，在开发这个程序之初并没有想把它做成一个完整的具有UI界面的功能集合包，因此一开始并没有工程布局的概念，需要做什么便在src下新建一个文件开始编码，这种习惯的弊端在随着程序愈发庞大而变得愈发清晰，使程序越来越难管理且开发难度增大。之后抽时间将程序整理了一遍，便形成了这种布局。个人观念，仅供参考。

我的工程布局思想主要遵循两个原则：

归类

相同属性或相同功能或本质相同的文件放在一个目录下，如：图片，文本等文件属于输入文件，只可被调用，因此放在同一目录res下，当然，res下可再做区分，img，icon，txt等。不同的功能区UI可放在同一目录下，这样可以将primeWindow与功能UI区分开来，且方便primeWindow调用功能UI，来实现功能的切换。功能的实现放在tools目录下，classes可以调用tools下相应的功能。tools目录下，部分功能过于复杂无法用一个文件完成也可以再建立子目录。

重复调用

如果遇到需要反复调用的功能，可集成出来单独形成一个方法单独存放，方便不同文件的调用，而不需要重复实现，如文本框，单行文本框，按钮等样式，实现选择文件等功能

基于PyQt开发的脚本集合包（一）

Fri, 01 Nov 2024 10:30:00 +0800

前言

作者因为工作需要，用python写了一些脚本用于数据处理，UTF-8转换，以及一些我的工作专属脚本，又因为想要偷懒，用爬虫爬取了微软翻译的页面做了一个自己的翻译器，近来突发奇想，想要把各种python写的脚本整合到一起，并写一个GUI应用程序，因此PyQt进入了我的视野。想着用业余时间一点一点摸索，到目前为止算是做的有模有样，现写博客记录下来。

这个GUI程序会分成一个系列更新，把我的UI框架，布局，工程整理，功能编写等等都写出来，包括：利用爬虫爬取微软翻译来做自己的翻译器，图像处理等。

本脚本工具包还在持续更新（部分功能我也还没有完成），目前还没有做完的功能有：做音频数据处理（抓取BLE音频数据包，自动去包头去CRC校验，获取raw data的功能），音频编解码（利用市面上常见开源编解码器对音频数据进行编码或解码，ADPCM，SBC等），后续根据需要和精力，看能不能做音频数据的时域频域转换器等等。都是美好幻想，敬请期待！

因为程序还在不断地完善更新，所以到系列结束时，代码应该就已经更新完成了，到时候我会将代码开源到我的GitHub仓库上，有兴趣的小伙伴可以下载使用或交流学习。本系列文章也会同步更新到我的CSDN博客中，如果小伙伴们觉得本系列对你有帮助，麻烦点个赞与收藏，感激不敬！

环境配置

1.1 Python环境

python下载

python下载网上有许多教程，这里不赘述了，我的编程环境是vscode，创建虚拟环境，

创建虚拟环境

1

python -m venv myPyQt #创建虚拟环境，命名为myPyQt

可以在终端查看包列表

1
2


pip list
# 看列表中是否有PyQt5相关的包

1.2 PyQt5安装

创建好虚拟环境后先进入虚拟环境，然后在该虚拟环境中下载PyQt5

1

pip install PyQt5 -i https://pypi.tuna.tsinghua.edu.cn/simple # -i + 地址 为从国内镜像网站下载，提升下载速度

下载好qt后可以测试一下是否安装成功

1
2
3


from PyQt5.QtCore import *
print(QT_VERSION_STR)
# 如果没有报错，则说明安装成功

1.3 Pyinstaller

打包命令：

1

pyinstaller -n yourProgramName -i icon/path/icon.ico --add-data "path/xxx.png;." --add-data "CanAddLotData.ico;path/in/__interval" -w main.py

-n：你程序的名字
-i：你应用的图标，如果与程序入口（main）不在同一目录下，则需要给出相应的路径
–add-data：链接外部资源，比如图片，图标等资源，该参数分为两个部分，使用“:”（Linux）或“;”（Windows）隔开，前面是打包前该文件的路径，后面是打包后该文件要保存的路径，下面是重点

值得注意的是，pyinstaller在v6.0版本以后，如果没有加入--onefile参数，那么打包后会生成一个附带的目录__internal，打包后你的文件会保存在该目录下，比如：--add-data "res/xx.icon;res/xx.icon"，那么pyinstaller会在与main.py相同的目录下寻找一个res目录下的xx.icon文件，将其作为外部资源链接到程序中，并在__internal目录下创建一个res目录，存放一个xx.icon文件。如果你使用了--onefile参数，那么将不会创建__internal目录，res目录将会创建在与exe文件相同的目录下。GitHub上有对该问题的解释：Regression: datas moved to _internal in pyinstaller 6.1.0. pyinstaller 5.13.1 puts datas in correct directory · Issue #8075 · pyinstaller/pyinstaller

切记切记这一点，因为这影响到你程序中调用资源文件时该如何填写路径，如果还没弄懂没有关系，后面会在代码中详细解释
-w：此参数用于创建不显示命令行窗口的GUI程序，即：避免应用程序运行时弹出命令行窗口
main.py：程序入口

如果你在使用 -i 命令时遇到来了以下报错：

1

Received icon image 'D:\python\MyScriptTools\src\icon.ico' which exists but is not in the correct format. On this platform, only ('exe', 'ico') images may be used as icons. If Pillow is installed, automatic conversion will be attempted. Please install Pillow or convert your 'ico' file to one of ('exe', 'ico') and try again.

说明你使用的图标文件格式不正确，只有exe或ico格式的图像才可以用作图标。如果系统无法识别你的ico或你只有jpg或png等格式的图标，可以安装pillow，它会为你解决一切

1

pip install pillow

那么到此为止，你做好了开发PyQt的前置工作

Python on 苏三有春的博客

如何在Windows中使用opuslib库

前言

你是否需要opuslib

下载opuslib

opuslib使用异常

下载opus.dll

配置opus动态库

小结

pyinstaller无法打包第三方库

Opus解码器样例

基于PyQt开发的脚本集合包（十四）

前言

UI布局展示

代码展示

PcmBUilderClass.py

pcmBuilder.py

示例

逐步处理

最终列表

基于PyQt开发的脚本集合包（十三）

前言

播放器思想

代码展示

音频波形与音频播放的同步

如何避免音频卡顿

UI线程与音频线程的阻塞问题

内存管理问题

PyAudio流的管理问题

PyAudio库基本知识详解

前言

前置知识

PyAudio

PyAudio的常见用途

安装 PyAudio

PyAudio的核心概念

主要功能

PyAudio的应用场景

PyAudio与其他音频库对比

注意事项

小结

stop_stream与start_stream

1. stream.start_stream() 的作用

2. stream.stop_stream() 的作用

为什么 start_stream() 有时没被显式调用

小结

谁开启的麦克风或扬声器

调用麦克风硬件的关键步骤：

总结：

基于PyQt开发的脚本集合包（十二）

前言

Python中的线程

创建线程

线程之间的消息传递

使用 queue.Queue 进行线程通信

使用 threading.Event 进行线程通信

使用 threading.Lock 和共享变量

使用 threading.Condition 进行更复杂的通信

编码器UI设计

解码器启动脚本

总结

基于PyQt开发的脚本集合包（十一）

前言

UI框架

进度条展示

代码详解

总结

进度条的更新实际上是对控件的重新绘制

通过消息队列传递更新消息

基于PyQt开发的脚本集合包（十）

前言

JSON数据处理UI

JSON数据的来源

JSON数据提取

总结

基于PyQt开发的脚本集合包（九）

前言

分析

IG

找到IG所在

为什么 `start_stream()` 有时没被显式调用

使用 `queue.Queue` 进行线程通信

使用 `threading.Event` 进行线程通信

使用 `threading.Lock` 和共享变量

使用 `threading.Condition` 进行更复杂的通信

找到`IG`所在

请求获取`IG`数据

`User-Agent` 的作用总结：

找到`IID`的所在

找到`token`与`key`的所在

def init

1. `QApplication` 类

2. `sys.argv` 的作用