从代码到独立程序：Cython与Pyinstaller打包全流程详解

发表于 2024-11-28 17:07:58 更新于 2024-12-03 22:09:18 分类于 Python

引言

前面的文章中写了通过 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 编译+打包的整个流程了，如果有问题的小伙伴可以在下面留言评论，大家一起讨论。

本文章首发于个人博客 LLLibra146’s blog
本文作者：LLLibra146
更多文章请关注：
版权声明：本博客所有文章除特别声明外，均采用 © BY-NC-ND 许可协议。非商用转载请注明出处！严禁商业转载！
本文链接：
https://blog.d77.xyz/archives/33e70ed5.html