pyinstaller,nuitka,嵌入式打包性能比较

已于 2024-04-09 20:44:38 修改
阅读量1.9k 收藏 52
点赞数 55
文章标签： python pyqt numpy
于 2024-04-08 23:25:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65740074/article/details/137526680
版权
本文通过对比PyInstaller、Nuitka和直接嵌入式运行等方式对Pystone基准测试进行打包，探讨了不同打包方式对Python程序性能的影响，发现将脚本转为pyd文件能显著提高性能，特别是使用嵌入式+pyd模式。
摘要由CSDN通过智能技术生成

本文通过比较三种打包方式，来对比哪种打包方式打包的程序性能最好。

测试方式：

本文使用pystone.py来进行测试。

        Pystone.py是一个经典的 Python 性能测试脚本，最早由 Tim Peters 编写，用作衡量 Python 解释器性能的一个基准测试工具。Pystone 的名称来源于早期的 Ada 语言中的 PicoStone benchmark，它试图通过一系列的抽象操作（如对象创建、方法调用等）来模拟典型 Python 程序的运算特征。

        它包含一系列操作，这些操作被设计成能够尽可能涵盖多种类型的操作和数据结构，以便全面反映 Python 解释器在处理不同类型任务时的速度。Pystone 的执行结果通常以每秒执行的 Pystone 值（Pystones/second）为单位，不同版本的 Python 或不同硬件平台上，Pystone 值越高则表明解释器性能越好。

tips：

        随着时间推移和技术进步，pystone.py已经不再是最适合评估现代 Python 解释器性能的基准之一，因为它的设计相对简单，没有充分考虑到现代 CPU 架构和 Python 优化技术带来的影响。本文用它也仅仅是因为做个粗浅的测评。

以其输出的machine benchmarks作为性能衡量标准。该值越大，说明性能越好。

测试平台：

win11，python 3.8.18，pyinstaller 6.5.0 ，nuitka 2.1.5。

环境：使用conda新建python 3.8.18虚拟环境。

数据处理：以运行100次pystone.py为计算考量，统计machine benchmarks最大值，最小值，平均值。

代码架构：

包含main.py，pystone.py两个py文件。

main.py

import time

from pystone import ceshi

ceshi()

pystone.py

#!/usr/bin/env python3

"""
"PYSTONE" Benchmark Program

Version:        Python/1.1 (corresponds to C/1.1 plus 2 Pystone fixes)

Author:         Reinhold P. Weicker,  CACM Vol 27, No 10, 10/84 pg. 1013.

                Translated from ADA to C by Rick Richardson.
                Every method to preserve ADA-likeness has been used,
                at the expense of C-ness.

                Translated from C to Python by Guido van Rossum.

Version History:

                Version 1.1 corrects two bugs in version 1.0:

                First, it leaked memory: in Proc1(), NextRecord ends
                up having a pointer to itself.  I have corrected this
                by zapping NextRecord.PtrComp at the end of Proc1().

                Second, Proc3() used the operator != to compare a
                record to None.  This is rather inefficient and not
                true to the intention of the original benchmark (where
                a pointer comparison to None is intended; the !=
                operator attempts to find a method __cmp__ to do value
                comparison of the record).  Version 1.1 runs 5-10
                percent faster than version 1.0, so benchmark figures
                of different versions can't be compared directly.

"""

from __future__ import print_function

from time import perf_counter as clock

LOOPS = 50000

__version__ = "1.1"

[Ident1, Ident2, Ident3, Ident4, Ident5] = range(1, 6)


class Record(object):

    def __init__(self, PtrComp=None, Discr=0, EnumComp=0,
                 IntComp=0, StringComp=0):
        self.PtrComp = PtrComp
        self.Discr = Discr
        self.EnumComp = EnumComp
        self.IntComp = IntComp
        self.StringComp = StringComp

    def copy(self):
        return Record(self.PtrComp, self.Discr, self.EnumComp,
                      self.IntComp, self.StringComp)


TRUE = 1
FALSE = 0


def main(loops=LOOPS):
    benchtime, stones = pystones(loops)
    print("Pystone(%s) time for %d passes = %g" % \
          (__version__, loops, benchtime))
    print("This machine benchmarks at %g pystones/second" % stones)
    return stones


def pystones(loops=LOOPS):
    return Proc0(loops)


IntGlob = 0
BoolGlob = FALSE
Char1Glob = '\0'
Char2Glob = '\0'
Array1Glob = [0] * 51
Array2Glob = [x[:] for x in [Array1Glob] * 51]
PtrGlb = None
PtrGlbNext = None


def Proc0(loops=LOOPS):
    global IntGlob
    global BoolGlob
    global Char1Glob
    global Char2Glob
    global Array1Glob
    global Array2Glob
    global PtrGlb
    global PtrGlbNext

    starttime = clock()
    for i in range(loops):
        pass
    nulltime = clock() - starttime

    PtrGlbNext = Record()
    PtrGlb = Record()
    PtrGlb.PtrComp = PtrGlbNext
    PtrGlb.Discr = Ident1
    PtrGlb.EnumComp = Ident3
    PtrGlb.IntComp = 40
    PtrGlb.StringComp = "DHRYSTONE PROGRAM, SOME STRING"
    String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"
    Array2Glob[8][7] = 10

    starttime = clock()

    for i in range(loops):
        Proc5()
        Proc4()
        IntLoc1 = 2
        IntLoc2 = 3
        String2Loc = "DHRYSTONE PROGRAM, 2'ND STRING"
        EnumLoc = Ident2
        BoolGlob = not Func2(String1Loc, String2Loc)
        while IntLoc1 < IntLoc2:
            IntLoc3 = 5 * IntLoc1 - IntLoc2
            IntLoc3 = Proc7(IntLoc1, IntLoc2)
            IntLoc1 = IntLoc1 + 1
        Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3)
        PtrGlb = Proc1(PtrGlb)
        CharIndex = 'A'
        while CharIndex <= Char2Glob:
            if EnumLoc == Func1(CharIndex, 'C'):
                EnumLoc = Proc6(Ident1)
            CharIndex = chr(ord(CharIndex) + 1)
        IntLoc3 = IntLoc2 * IntLoc1
        IntLoc2 = IntLoc3 / IntLoc1
        IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1
        IntLoc1 = Proc2(IntLoc1)

    benchtime = clock() - starttime - nulltime
    if benchtime == 0.0:
        loopsPerBenchtime = 0.0
    else:
        loopsPerBenchtime = (loops / benchtime)
    return benchtime, loopsPerBenchtime


def Proc1(PtrParIn):
    PtrParIn.PtrComp = NextRecord = PtrGlb.copy()
    PtrParIn.IntComp = 5
    NextRecord.IntComp = PtrParIn.IntComp
    NextRecord.PtrComp = PtrParIn.PtrComp
    NextRecord.PtrComp = Proc3(NextRecord.PtrComp)
    if NextRecord.Discr == Ident1:
        NextRecord.IntComp = 6
        NextRecord.EnumComp = Proc6(PtrParIn.EnumComp)
        NextRecord.PtrComp = PtrGlb.PtrComp
        NextRecord.IntComp = Proc7(NextRecord.IntComp, 10)
    else:
        PtrParIn = NextRecord.copy()
    NextRecord.PtrComp = None
    return PtrParIn


def Proc2(IntParIO):
    IntLoc = IntParIO + 10
    while 1:
        if Char1Glob == 'A':
            IntLoc = IntLoc - 1
            IntParIO = IntLoc - IntGlob
            EnumLoc = Ident1
        if EnumLoc == Ident1:
            break
    return IntParIO


def Proc3(PtrParOut):
    global IntGlob

    if PtrGlb is not None:
        PtrParOut = PtrGlb.PtrComp
    else:
        IntGlob = 100
    PtrGlb.IntComp = Proc7(10, IntGlob)
    return PtrParOut


def Proc4():
    global Char2Glob

    BoolLoc = Char1Glob == 'A'
    BoolLoc = BoolLoc or BoolGlob
    Char2Glob = 'B'


def Proc5():
    global Char1Glob
    global BoolGlob

    Char1Glob = 'A'
    BoolGlob = FALSE


def Proc6(EnumParIn):
    EnumParOut = EnumParIn
    if not Func3(EnumParIn):
        EnumParOut = Ident4
    if EnumParIn == Ident1:
        EnumParOut = Ident1
    elif EnumParIn == Ident2:
        if IntGlob > 100:
            EnumParOut = Ident1
        else:
            EnumParOut = Ident4
    elif EnumParIn == Ident3:
        EnumParOut = Ident2
    elif EnumParIn == Ident4:
        pass
    elif EnumParIn == Ident5:
        EnumParOut = Ident3
    return EnumParOut


def Proc7(IntParI1, IntParI2):
    IntLoc = IntParI1 + 2
    IntParOut = IntParI2 + IntLoc
    return IntParOut


def Proc8(Array1Par, Array2Par, IntParI1, IntParI2):
    global IntGlob

    IntLoc = IntParI1 + 5
    Array1Par[IntLoc] = IntParI2
    Array1Par[IntLoc + 1] = Array1Par[IntLoc]
    Array1Par[IntLoc + 30] = IntLoc
    for IntIndex in range(IntLoc, IntLoc + 2):
        Array2Par[IntLoc][IntIndex] = IntLoc
    Array2Par[IntLoc][IntLoc - 1] = Array2Par[IntLoc][IntLoc - 1] + 1
    Array2Par[IntLoc + 20][IntLoc] = Array1Par[IntLoc]
    IntGlob = 5


def Func1(CharPar1, CharPar2):
    CharLoc1 = CharPar1
    CharLoc2 = CharLoc1
    if CharLoc2 != CharPar2:
        return Ident1
    else:
        return Ident2


def Func2(StrParI1, StrParI2):
    IntLoc = 1
    while IntLoc <= 1:
        if Func1(StrParI1[IntLoc], StrParI2[IntLoc + 1]) == Ident1:
            CharLoc = 'A'
            IntLoc = IntLoc + 1
    if CharLoc >= 'W' and CharLoc <= 'Z':
        IntLoc = 7
    if CharLoc == 'X':
        return TRUE
    else:
        if StrParI1 > StrParI2:
            IntLoc = IntLoc + 7
            return TRUE
        else:
            return FALSE


def Func3(EnumParIn):
    EnumLoc = EnumParIn
    if EnumLoc == Ident3: return TRUE
    return FALSE


def ceshi():
    import sys
    def error(msg):
        print(msg, end=' ', file=sys.stderr)
        print("usage: %s [number_of_loops]" % sys.argv[0], file=sys.stderr)
        sys.exit(100)

    nargs = len(sys.argv) - 1
    if nargs > 1:
        error("%d arguments are too many;" % nargs)
    elif nargs == 1:
        try:
            loops = int(sys.argv[1])
        except ValueError:
            error("Invalid argument %r;" % sys.argv[1])
    else:
        loops = LOOPS
    result = []
    for i in range(100):
        result.append(main(loops))

    print("平均结果", sum(result) / len(result))
    print("最大值", max(result))
    print("最小值", min(result))
    with open("result.txt", "w", encoding="utf-8") as file:
        file.write("平均结果" + str(sum(result) / len(result)) + "\n")
        file.write("最大值" + str(max(result)) + "\n")
        file.write("最小值" + str(min(result)) + "\n")

测试打包类型：

作为对比，以下增加pycharm作为参照组。

第一组

1，pyinstaller+py：使用pyinstaller将main.py打包为可执行文件（多文件形式）；

2，nuitka-nofollow：使用nuitka --nofollow-imports将main.py打包为可执行文件（依赖本机环境）；

3，nuitka-standalone：使用nuitka --standalone 将main.py打包为可执行文件（不依赖本机环境）；

4，嵌入式+py：使用Python 3.8.10 embeddable解释器将main.py打包为独立程序；

5，pycharm+py：使用pycharm运行main.py；

第二组

使用nuitka --module pystone.py 命令将pystone.py编译为pystone.cp38-win_amd64.pyd文件，然后再打包。

1，pyinstaller+pyd：同上。

2，nuitka-nofollow：同上。

3，nuitka-standalone：同上。

4，嵌入式+pyd：同上。

5，pycharm+pyd:同上。

测试结果如下：

benchmarks
测试类型最小值最大值平均值
pyinstaller+py149018.8228191208592.6
nuitka-nofollow196698.6227482.9215692.8
nuitka-standalone315474.1464840.4451053.6
嵌入式+py241302.6383055.2354852.4
pycharm+py198568.5225326.1215501.4
将pystone使用nuitka转为pyd文件
pyinstaller+pyd308124.1461324.4434051
nuitka-nofollow264691.2468959.6446176.9
nuitka-standalone238961.6461419.8443570.9
嵌入式+pyd372779.6598229.2558092.3
pycharm+pyd434866.9469542.6455194.4

数据处理

将pycharm+py的平均值测试数据设定为100%，归一化处理其他数据结果如下：

benchmarks
测试类型最小值最大值平均值
pyinstaller+py69.15%105.89%96.79%
nuitka-nofollow91.27%105.56%100.09%
nuitka-standalone146.39%215.70%209.30%
嵌入式+py111.97%177.75%164.66%
pycharm+py92.14%104.56%100.00%
将pystone使用nuitka转为pyd文件
pyinstaller+pyd142.98%214.07%201.41%
nuitka-nofollow122.83%217.61%207.04%
nuitka-standalone110.89%214.11%205.83%
嵌入式+pyd172.98%277.60%258.97%
pycharm+pyd201.79%217.88%211.23%

将第一组测试结果绘图如下：

将第二组的测试结果绘图如下：

结论

可以直观的看出：

1，将py文件转为pyd文件可以显著提升性能。

2，py文件不单独转为pyd的话，使用nuitka打包程序，性能提升明显。

3，将py文件转为pyd之后，使用嵌入式+pyd的打包模式，性能遥遥领先于其他的打包办法。

那么问题来了，怎么实现嵌入式打包呢？请看下面的文章：

python嵌入式打包，新打包姿势

孟德尔单杀豌豆射手
关注
  • 55
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Pyinstaller将py打包成exe的实例
09-20
- 打包后的exe文件可能会比较大，因为包含了所有依赖项。对于大型项目，考虑使用`--onefile`选项可能会导致启动速度变慢，因为所有资源都需要解压到内存中才能运行。 - 使用`--debug`选项可以帮助调试打包过程中可能...
记录nuitka打包遇见的坑以及打包步骤
qq_61721575的博客
07-01 1609
介绍了nuitka是如何一步步完成打包的
Python 打包工具 Nuitka 入门指南
m0_66570838的博客
08-11 1万+
本文主要讲述了python打包工具nuitka的使用
Nuitka打包教程
Good Luck
11-30 1万+
python打包之Nuitka打包教程
nuitka打包
*****
05-28 6984
nuitka打包
Python——Windows使用Nuitka2.0打包（保姆级教程）
Pan_peter的博客
03-02 1万+
介绍了如何使用Python自带的venv模块创建和管理虚拟环境，从基本的创建、激活到安装项目所需的包。此外，文章还深入探讨了Nuitka这一强大的Python编译器，它可以将Python项目转换为独立的可执行文件，极大地提升了项目的移植性和运行效率。通过一系列步骤和示例代码，读者可以学习如何利用Nuitka打包Python项目，包括常用的命令参数和打包策略。
基于Nuitka的快速打包工具EasyNuitka
loujiand的博客
02-15 6431
Nuitka打包工具EasyNuitka
Pyinstaller加密打包应用的示例代码
09-16
PyInstaller是一款强大的Python程序打包工具，它可以将Python脚本转换为独立的可执行文件，适用于Windows、Linux、Mac OS等操作系统。通过PyInstaller，开发者可以轻松地将Python应用程序打包成单个可执行文件，便于...
解决pyinstaller打包pyqt5的问题
09-19
### 解决pyinstaller打包pyqt5的问题 #### 问题背景 在使用`pyinstaller`工具进行基于`PyQt5`的应用程序打包时，经常会遇到一些挑战。特别是在Windows平台上，由于`pyinstaller`在构建可执行文件时可能无法正确...
Pyinstaller打包的程序源码
最新发布
08-05
本文时通过Pyinstaller打包含有pyqt5控件的源码，含有主程序以及控件程序实现代码
基于Pyinstaller打包Python程序并压缩文件大小
09-16
**Pyinstaller 打包 Python 程序及压缩文件大小** Pyinstaller 是一个用于将 Python 程序转换为独立可执行文件的工具，适用于多种操作系统。它允许开发者将 Python 代码及其依赖项封装在一起，形成一个易于分发的单...
使用nuitka打包python代码为exe可执行程序
热门推荐
ha_lee的博客
04-15 2万+
使用nuitka打包python的pyqt5项目详细过程介绍以及遇见bug解决方法
python打包之一文打尽：pyinstaller 和 nuitka 打包参数与使用方法详解
qq_58168857的博客
11-23 6237
本文介绍了pyinstaller 和 nuitka 两种打包工具的使用，由于网上pyinstaller打包方面的文章较多，本文就较详细介绍了nuitka打包工具的使用。相比较而言，pyinstaller使用相对简单，而nuitka 使用比较复杂，但打出的包体积小，运行速度快，两种打包工具各有所长，读者可根据需要进行选用。
Nuitka 和 PyInstaller 对比
u012219045的专栏
05-30 2385
与 Nuitka 不同，PyInstaller 不编译 Python 代码，而是利用操作系统的特性，将所有的 Python 依赖项打包到一个文件中，使得 Python 应用程序能够独立运行，而无需安装任何依赖项。由于 Nuitka 旨在提供更好的性能和效率，因此它需要编译和优化 Python 代码，这使得 Nuitka 的配置和使用可能会较为繁琐和复杂。如果您需要处理小型的 Python 项目，需要简单到易于上手的工具，并且不需要太高的性能，那么 PyInstaller 将是一个不错的选择。
《Nuitka打包实战指南》实战打包openpyxl
热爱代码
02-10 1761
实战打包openpyxl 打包示例源码： 请看文章末尾 版本信息： openpyxl==3.0.9 Nuitka==0.6.19.1 打包系统： Windows10 64位 项目目录如下：
python 打包可执行文件-Nuitka详解
做减求空
10-07 2950
`Nuitka`是用Python编写的优化Python编译器，它可以创建运行时不需要单独安装程序的可执行文件。简单易使用，与Python2（2.6、2.7）和Python3（3.3-3.10）完全兼容，适用于Windows、macOS、Linux等平台。
Nuitka打包
qq_43640977的博客
07-10 479
本文仅供本人知识总结使用，所以内容会比较浅显，不喜勿喷。
pyinstaller多文件打包
11-29
以下是使用pyinstaller进行多文件打包的步骤： 1.使用pyinstaller命令进行多文件打包，其中--add-data参数用于添加需要打包的文件，格式为'源文件路径;目标路径'，多个文件之间用空格隔开。例如： ```shell pyinstaller -F --add-data 'use_ico.png;./' format_conversion.py ``` 2.如果需要对打包过程进行更加详细的配置，可以先使用pyinstaller生成.spec文件，然后在.spec文件中进行配置，最后使用pyinstaller命令进行打包。具体步骤如下： ```shell # 生成.spec文件 pyinstaller -makespec xxx.py # 修改.spec文件中的配置 # ... # 使用.spec文件进行打包 pyinstaller xxx.spec ``` 注意：在修改.spec文件时，需要注意文件路径的设置，以及需要打包的文件和依赖库的添加。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值