引言
前面的文章中写了通过 Cython 编译 py 文件到 so 文件的方法，可以加固并保护我们的源代码，当时提到了如果使用 Pyinstaller 打包的话要将编译产物一起分发，有小伙伴问如何将编译产物一起分发，今天我们分享一下。
PySide6
还有小伙伴问 PySide6 如何使用 Cython 编译，说是有兼容性问题，我这里一并测试一下。
PySide6
首先我要找一个代码量稍微多一点的 PySide6 的 demo，之前在 PySide2 的时候还是 PyQt5 的时候，我记得官方的 demo 是和库放到一起的，但是我看了一下 PySide6 的库里面没有了，找了一下，原来是单独有一个库，地址是：https://pypi.org/project/PySide6-Examples/，和正常的 Python 库一样直接安装就可以使用了。如果不想安装的话也可以直接使用云端的仓库，地址是：https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples
官方的 demo 包含了所有模块的 demo，大家在写代码的时候可以拿官方的 demo 作为参考。
demo
这里我选择了一个俄罗斯方块的作为本次打包使用的 demo，先看代码：
"""PySide6 port of the widgets/widgets/tetrix example from Qt v5.x"""
import random
import sys
from enum import IntEnum
from PySide6.QtCore import QBasicTimer, QSize, Qt, Signal, Slot
from PySide6.QtGui import QColor, QPainter, QPixmap
from PySide6.QtWidgets import (QFrame, QGridLayout, QLabel,
QLCDNumber, QPushButton, QWidget)
class Piece(IntEnum):
NoShape = 0
ZShape = 1
SShape = 2
LineShape = 3
TShape = 4
SquareShape = 5
LShape = 6
MirroredLShape = 7
class TetrixWindow(QWidget):
def __init__(self):
super().__init__()
self.board = TetrixBoard()
next_piece_label = QLabel()
next_piece_label.setFrameStyle(QFrame.Box | QFrame.Raised)
next_piece_label.setAlignment(Qt.AlignCenter)
self.board.set_next_piece_label(next_piece_label)
score_lcd = QLCDNumber(5)
score_lcd.setSegmentStyle(QLCDNumber.Filled)
level_lcd = QLCDNumber(2)
level_lcd.setSegmentStyle(QLCDNumber.Filled)
lines_lcd = QLCDNumber(5)
lines_lcd.setSegmentStyle(QLCDNumber.Filled)
start_button = QPushButton("&Start")
start_button.setFocusPolicy(Qt.NoFocus)
quit_button = QPushButton("&Quit")
quit_button.setFocusPolicy(Qt.NoFocus)
pause_button = QPushButton("&Pause")
pause_button.setFocusPolicy(Qt.NoFocus)
start_button.clicked.connect(self.board.start)
pause_button.clicked.connect(self.board.pause)
quit_button.clicked.connect(sys.exit)
self.board.score_changed.connect(score_lcd.display)
self.board.level_changed.connect(level_lcd.display)
self.board.lines_removed_changed.connect(lines_lcd.display)
layout = QGridLayout(self)
layout.addWidget(self.create_label("NEXT"), 0, 0)
layout.addWidget(next_piece_label, 1, 0)
layout.addWidget(self.create_label("LEVEL"), 2, 0)
layout.addWidget(level_lcd, 3, 0)
layout.addWidget(start_button, 4, 0)
layout.addWidget(self.board, 0, 1, 6, 1)
layout.addWidget(self.create_label("SCORE"), 0, 2)
layout.addWidget(score_lcd, 1, 2)
layout.addWidget(self.create_label("LINES REMOVED"), 2, 2)
layout.addWidget(lines_lcd, 3, 2)
layout.addWidget(quit_button, 4, 2)
layout.addWidget(pause_button, 5, 2)
self.setWindowTitle("Tetrix")
self.resize(550, 370)
def create_label(self, text):
lbl = QLabel(text)
lbl.setAlignment(Qt.AlignHCenter | Qt.AlignBottom)
return lbl
class TetrixBoard(QFrame):
board_width = 10
board_height = 22
score_changed = Signal(int)
level_changed = Signal(int)
lines_removed_changed = Signal(int)
def __init__(self, parent=None):
super().__init__(parent)
self.timer = QBasicTimer()
self.nextPieceLabel = None
self._is_waiting_after_line = False
self._cur_piece = TetrixPiece()
self._next_piece = TetrixPiece()
self._cur_x = 0
self._cur_y = 0
self._num_lines_removed = 0
self._num_pieces_dropped = 0
self.score = 0
self.level = 0
self.board = None
self.setFrameStyle(QFrame.Panel | QFrame.Sunken)
self.setFocusPolicy(Qt.StrongFocus)
self._is_started = False
self._is_paused = False
self.clear_board()
self._next_piece.set_random_shape()
def shape_at(self, x, y):
return self.board[(y * TetrixBoard.board_width) + x]
def set_shape_at(self, x, y, shape):
self.board[(y * TetrixBoard.board_width) + x] = shape
def timeout_time(self):
return 1000 / (1 + self.level)
def square_width(self):
return self.contentsRect().width() / TetrixBoard.board_width
def square_height(self):
return self.contentsRect().height() / TetrixBoard.board_height
def set_next_piece_label(self, label):
self.nextPieceLabel = label
def sizeHint(self):
return QSize(TetrixBoard.board_width * 15 + self.frameWidth() * 2,
TetrixBoard.board_height * 15 + self.frameWidth() * 2)
def minimum_size_hint(self):
return QSize(TetrixBoard.board_width * 5 + self.frameWidth() * 2,
TetrixBoard.board_height * 5 + self.frameWidth() * 2)
@Slot()
def start(self):
if self._is_paused:
return
self._is_started = True
self._is_waiting_after_line = False
self._num_lines_removed = 0
self._num_pieces_dropped = 0
self.score = 0
self.level = 1
self.clear_board()
self.lines_removed_changed.emit(self._num_lines_removed)
self.score_changed.emit(self.score)
self.level_changed.emit(self.level)
self.new_piece()
self.timer.start(self.timeout_time(), self)
@Slot()
def pause(self):
if not self._is_started:
return
self._is_paused = not self._is_paused
if self._is_paused:
self.timer.stop()
else:
self.timer.start(self.timeout_time(), self)
self.update()
def paintEvent(self, event):
super(TetrixBoard, self).paintEvent(event)
with QPainter(self) as painter:
rect = self.contentsRect()
if self._is_paused:
painter.drawText(rect, Qt.AlignCenter, "Pause")
return
board_top = rect.bottom() - TetrixBoard.board_height * self.square_height()
for i in range(TetrixBoard.board_height):
for j in range(TetrixBoard.board_width):
shape = self.shape_at(j, TetrixBoard.board_height - i - 1)
if shape != Piece.NoShape:
self.draw_square(painter,
rect.left() + j * self.square_width(),
board_top + i * self.square_height(), shape)
if self._cur_piece.shape() != Piece.NoShape:
for i in range(4):
x = self._cur_x + self._cur_piece.x(i)
y = self._cur_y - self._cur_piece.y(i)
self.draw_square(painter, rect.left() + x * self.square_width(),
board_top
+ (TetrixBoard.board_height - y - 1) * self.square_height(),
self._cur_piece.shape())
def keyPressEvent(self, event):
if not self._is_started or self._is_paused or self._cur_piece.shape() == Piece.NoShape:
super(TetrixBoard, self).keyPressEvent(event)
return
key = event.key()
if key == Qt.Key_Left:
self.try_move(self._cur_piece, self._cur_x - 1, self._cur_y)
elif key == Qt.Key_Right:
self.try_move(self._cur_piece, self._cur_x + 1, self._cur_y)
elif key == Qt.Key_Down:
self.try_move(self._cur_piece.rotated_right(), self._cur_x, self._cur_y)
elif key == Qt.Key_Up:
self.try_move(self._cur_piece.rotated_left(), self._cur_x, self._cur_y)
elif key == Qt.Key_Space:
self.drop_down()
elif key == Qt.Key_D:
self.one_line_down()
else:
super(TetrixBoard, self).keyPressEvent(event)
def timerEvent(self, event):
if event.timerId() == self.timer.timerId():
if self._is_waiting_after_line:
self._is_waiting_after_line = False
self.new_piece()
self.timer.start(self.timeout_time(), self)
else:
self.one_line_down()
else:
super(TetrixBoard, self).timerEvent(event)
def clear_board(self):
self.board = [
Piece.NoShape for _ in range(TetrixBoard.board_height * TetrixBoard.board_width)]
def drop_down(self):
drop_height = 0
new_y = self._cur_y
while new_y > 0:
if not self.try_move(self._cur_piece, self._cur_x, new_y - 1):
break
new_y -= 1
drop_height += 1
self.piece_dropped(drop_height)
def one_line_down(self):
if not self.try_move(self._cur_piece, self._cur_x, self._cur_y - 1):
self.piece_dropped(0)
def piece_dropped(self, dropHeight):
for i in range(4):
x = self._cur_x + self._cur_piece.x(i)
y = self._cur_y - self._cur_piece.y(i)
self.set_shape_at(x, y, self._cur_piece.shape())
self._num_pieces_dropped += 1
if self._num_pieces_dropped % 25 == 0:
self.level += 1
self.timer.start(self.timeout_time(), self)
self.level_changed.emit(self.level)
self.score += dropHeight + 7
self.score_changed.emit(self.score)
self.remove_full_lines()
if not self._is_waiting_after_line:
self.new_piece()
def remove_full_lines(self):
num_full_lines = 0
for i in range(TetrixBoard.board_height - 1, -1, -1):
line_is_full = True
for j in range(TetrixBoard.board_width):
if self.shape_at(j, i) == Piece.NoShape:
line_is_full = False
break
if line_is_full:
num_full_lines += 1
for k in range(i, TetrixBoard.board_height - 1):
for j in range(TetrixBoard.board_width):
self.set_shape_at(j, k, self.shape_at(j, k + 1))
for j in range(TetrixBoard.board_width):
self.set_shape_at(j, TetrixBoard.board_height - 1, Piece.NoShape)
if num_full_lines > 0:
self._num_lines_removed += num_full_lines
self.score += 10 * num_full_lines
self.lines_removed_changed.emit(self._num_lines_removed)
self.score_changed.emit(self.score)
self.timer.start(500, self)
self._is_waiting_after_line = True
self._cur_piece.set_shape(Piece.NoShape)
self.update()
def new_piece(self):
self._cur_piece = self._next_piece
self._next_piece.set_random_shape()
self.show_next_piece()
self._cur_x = TetrixBoard.board_width // 2 + 1
self._cur_y = TetrixBoard.board_height - 1 + self._cur_piece.min_y()
if not self.try_move(self._cur_piece, self._cur_x, self._cur_y):
self._cur_piece.set_shape(Piece.NoShape)
self.timer.stop()
self._is_started = False
def show_next_piece(self):
if self.nextPieceLabel is not None:
return
dx = self._next_piece.max_x() - self._next_piece.min_x() + 1
dy = self._next_piece.max_y() - self._next_piece.min_y() + 1
pixmap = QPixmap(dx * self.square_width(), dy * self.square_height())
with QPainter(pixmap) as painter:
painter.fillRect(pixmap.rect(), self.nextPieceLabel.palette().background())
for i in range(4):
x = self._next_piece.x(i) - self._next_piece.min_x()
y = self._next_piece.y(i) - self._next_piece.min_y()
self.draw_square(painter, x * self.square_width(),
y * self.square_height(), self._next_piece.shape())
self.nextPieceLabel.setPixmap(pixmap)
def try_move(self, newPiece, newX, newY):
for i in range(4):
x = newX + newPiece.x(i)
y = newY - newPiece.y(i)
if x < 0 or x >= TetrixBoard.board_width or y < 0 or y >= TetrixBoard.board_height:
return False
if self.shape_at(x, y) != Piece.NoShape:
return False
self._cur_piece = newPiece
self._cur_x = newX
self._cur_y = newY
self.update()
return True
def draw_square(self, painter, x, y, shape):
color_table = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
color = QColor(color_table[shape])
painter.fillRect(x + 1, y + 1, self.square_width() - 2, self.square_height() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.square_height() - 1, x, y)
painter.drawLine(x, y, x + self.square_width() - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + self.square_height() - 1,
x + self.square_width() - 1, y + self.square_height() - 1)
painter.drawLine(x + self.square_width() - 1,
y + self.square_height() - 1, x + self.square_width() - 1, y + 1)
class TetrixPiece(object):
coords_table = (
((0, 0), (0, 0), (0, 0), (0, 0)),
((0, -1), (0, 0), (-1, 0), (-1, 1)),
((0, -1), (0, 0), (1, 0), (1, 1)),
((0, -1), (0, 0), (0, 1), (0, 2)),
((-1, 0), (0, 0), (1, 0), (0, 1)),
((0, 0), (1, 0), (0, 1), (1, 1)),
((-1, -1), (0, -1), (0, 0), (0, 1)),
((1, -1), (0, -1), (0, 0), (0, 1))
)
def __init__(self):
self.coords = [[0, 0] for _ in range(4)]
self._piece_shape = Piece.NoShape
self.set_shape(Piece.NoShape)
def shape(self):
return self._piece_shape
def set_shape(self, shape):
table = TetrixPiece.coords_table[shape]
for i in range(4):
for j in range(2):
self.coords[i][j] = table[i][j]
self._piece_shape = shape
def set_random_shape(self):
self.set_shape(random.randint(1, 7))
def x(self, index):
return self.coords[index][0]
def y(self, index):
return self.coords[index][1]
def set_x(self, index, x):
self.coords[index][0] = x
def set_y(self, index, y):
self.coords[index][1] = y
def min_x(self):
m = self.coords[0][0]
for i in range(4):
m = min(m, self.coords[i][0])
return m
def max_x(self):
m = self.coords[0][0]
for i in range(4):
m = max(m, self.coords[i][0])
return m
def min_y(self):
m = self.coords[0][1]
for i in range(4):
m = min(m, self.coords[i][1])
return m
def max_y(self):
m = self.coords[0][1]
for i in range(4):
m = max(m, self.coords[i][1])
return m
def rotated_left(self):
if self._piece_shape == Piece.SquareShape:
return self
result = TetrixPiece()
result._piece_shape = self._piece_shape
for i in range(4):
result.set_x(i, self.y(i))
result.set_y(i, -self.x(i))
return result
def rotated_right(self):
if self._piece_shape == Piece.SquareShape:
return self
result = TetrixPiece()
result._piece_shape = self._piece_shape
for i in range(4):
result.set_x(i, -self.y(i))
result.set_y(i, self.x(i))
return result将上面的代码保存为 tetrix_piece.py
运行以下代码，即可得到一个可以正常玩的俄罗斯方块游戏：
import random
import sys
from PySide6.QtWidgets import QApplication
from tetrix_piece import TetrixWindow
if __name__ == '__main__':
app = QApplication(sys.argv)
window = TetrixWindow()
window.show()
random.seed(None)
sys.exit(app.exec())运行截图：
以上就是本次的 demo，是一个可以正常运行的俄罗斯方块游戏。下面对它进行 Cython 编译，并且使用 Pyinstaller 打包成可执行文件。
Cython编译
准备文件
现在我们有两个文件，一个启动文件，main.py 和 tetrix_piece.py，要想使用 Cython 进行编译，我们还需要一个 setup.py 文件，之前的文章中已经提到了，文件内容如下：
# setup.py
from distutils.core import setup
from Cython.Build import cythonize
setup(
name='cython_project',
ext_modules=cythonize("tetrix_piece.py", language_level=3),
)编译 so
现在执行 python setup.py build_ext --inplace 命令开始编译，得到 tetrix_piece.cpython-310-darwin.so 文件。
现在将 tetrix_piece.py 文件改名，改成其他名字，运行 main.py 可以看到游戏还是可以正常运行的。这个时候 so 文件相当于替换了之前的模块，可以被正常导入到 Python 中。目前来看，PySide6 和 Cython 一起使用并没有发现有兼容性问题。
Pyinstaller
打包
现在我们有 so 文件和启动文件，可以开始打包工作了。使用 Pyinstaller 打包很简单，和 Cython 差不多，只需要运行打包命令即可。
执行以下命令进行打包：pyinstaller main.py
打包产物
打包后，我们得到了以下文件结构：
❯ tree -L 2 dist
dist
└── main
├── _internal
└── main
3 directories, 1 file运行 main 可执行文件，发现游戏可以正常运行。查看 _internal 文件夹，发现已经把我们编译好的 so 文件打包到了文件夹中，并且游戏也可以正常加载并且正常运行。
❯ tree -L 3 -P *.so dist
dist
└── main
└── _internal
├── PySide6
├── Python.framework
├── lib-dynload
├── shiboken6
└── tetrix_piece.cpython-310-darwin.so
7 directories, 1 file如果想打包成单个可执行文件，那么在 Pyinstaller 命令中添加 -F 参数即可。
打包脚本
到现在为止，整个打包流程就结束了，为了方便后续打包，我们将前面的命令写成一个打包脚本，实现一键打包。脚本如下：
rm -r dist
rm -r build
python setup.py build_ext --inplace
mv tetrix_piece.py tetrix_piece_bak.py
rm -r dist
rm *.spec
rm -r build
rm *.c
pyinstaller main.py
rm *.spec
rm -r build
mv tetrix_piece_bak.py tetrix_piece.py打包产物过大
Pyinstaller 一直以来有个问题就是打包产物过大，之前的问题是 Pyinstaller 在打包的时候会添加依赖库到打包产物中，在检测的时候会将一些用不到的依赖也打包进去，导致最终的产物可能会包含大量的无用依赖，一个最简单的程序可能也会有几百 M+。
现在看起来这个问题已经改善了许多了，我当前的环境安装了大量的依赖，但是我看了一下，最终被打包进来的依赖只有 Python 内置库和 PySide6 的依赖，没有其他的了。打包后的文件夹大小只有 100M，即使压缩后也有 35M。
这里我分享一个对打包产物继续瘦身的方法，那就是删除其他无用的依赖，即使是 PySide6 的依赖，也可以删除，先看下打包产物中有哪些 PySide6 的依赖：
❯ tree -L 3 dist
dist
└── main
├── _internal
│ ├── PySide6
│ ├── Python -> Python.framework/Versions/3.10/Python
│ ├── Python.framework
│ ├── QtCore -> PySide6/Qt/lib/QtCore.framework/Versions/A/QtCore
│ ├── QtDBus -> PySide6/Qt/lib/QtDBus.framework/Versions/A/QtDBus
│ ├── QtGui -> PySide6/Qt/lib/QtGui.framework/Versions/A/QtGui
│ ├── QtNetwork -> PySide6/Qt/lib/QtNetwork.framework/Versions/A/QtNetwork
│ ├── QtOpenGL -> PySide6/Qt/lib/QtOpenGL.framework/Versions/A/QtOpenGL
│ ├── QtPdf -> PySide6/Qt/lib/QtPdf.framework/Versions/A/QtPdf
│ ├── QtQml -> PySide6/Qt/lib/QtQml.framework/Versions/A/QtQml
│ ├── QtQmlMeta -> PySide6/Qt/lib/QtQmlMeta.framework/Versions/A/QtQmlMeta
│ ├── QtQmlModels -> PySide6/Qt/lib/QtQmlModels.framework/Versions/A/QtQmlModels
│ ├── QtQmlWorkerScript -> PySide6/Qt/lib/QtQmlWorkerScript.framework/Versions/A/QtQmlWorkerScript
│ ├── QtQuick -> PySide6/Qt/lib/QtQuick.framework/Versions/A/QtQuick
│ ├── QtSvg -> PySide6/Qt/lib/QtSvg.framework/Versions/A/QtSvg
│ ├── QtVirtualKeyboard -> PySide6/Qt/lib/QtVirtualKeyboard.framework/Versions/A/QtVirtualKeyboard
│ ├── QtWidgets -> PySide6/Qt/lib/QtWidgets.framework/Versions/A/QtWidgets
│ ├── base_library.zip
│ ├── lib-dynload
│ ├── libcrypto.3.dylib
│ ├── libintl.8.dylib
│ ├── liblzma.5.dylib
│ ├── libpyside6.abi3.6.8.dylib -> PySide6/libpyside6.abi3.6.8.dylib
│ ├── libshiboken6.abi3.6.8.dylib -> shiboken6/libshiboken6.abi3.6.8.dylib
│ ├── libssl.3.dylib
│ ├── shiboken6
│ └── tetrix_piece.cpython-310-darwin.so
└── main
7 directories, 24 files查看打包产物中的动态链接库文件，可以看到，我们只是写了一个俄罗斯方块小游戏，并没有使用到网络和 svg，pdf 等等模块，但是它们都被导入进来了，我们可以对这些无用的依赖进行删除操作，但是不会对游戏的运行产生影响。
那么如何判断我们删除的动态链接库是否会对程序造成影响呢，很简单，挨个试，每当删除一个或几个动态链接库时，运行一下程序的所有功能没有问题说明被删除的动态链接库并没有使用到，可以安全删除。
使用此方法可以将程序删减到 59M，压缩之后只有 20M 了，我没有挨个尝试删除，只是将看起来用不到的先删除了，现在看来效果还是很好的。毕竟是 GUI 程序，加上一些必要的核心库和 Python 本身的解释器，这个大小已经很不错了。
自动导入依赖 so
这里要说一下，之前版本的 Pyinstaller 貌似还没有这么智能，在打包的时候要手动指定 so 文件所在的文件夹，才能把我们需要的 so 文件打包到文件夹中，现在的 Pyinstaller 可能变得更加智能了，已经可以做到自动分析并且添加所需要的 so 文件了。
如果大家在打包的过程中，发现没有自动导入我们需要的依赖或者 so 文件，可以手动指定，让 Pyinstaller 强制导入对应的依赖，贴一个之前工作时候使用的打包命令：
pyinstaller -F main.py --hidden-import logging.handlers --hidden-import configparser --hidden-import pyodbc --hidden-import sqlalchemy --hidden-import asyncua --hidden-import aiohttp --hidden-import aredis --hidden-import sqlalchemy.sql.default_comparator --hidden-import sqlalchemy.ext.asyncio --hidden-import sqlalchemy.ext.declarative --distpath ./使用 --hidden-import 参数可以指定 Pyinstaller 导入对应的依赖。
总结
以上就是使用 Pyinstaller+Cython 编译+打包的整个流程了，如果有问题的小伙伴可以在下面留言评论，大家一起讨论。
python
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。