Introduction à Nuitka : une meilleure façon de compiler et de distribuer Python

Traducteur | Li Rui

Critique | Sun Shujuan

À mesure que Python devient de plus en plus populaire, ses limites deviennent de plus en plus évidentes. D'une part, écrire des applications Python et les distribuer à des personnes sur lesquelles Python n'est pas installé peut être très difficile.

Le moyen le plus courant de résoudre ce problème consiste à empaqueter le programme avec toutes ses bibliothèques et fichiers de support ainsi que le runtime Python. Il existe des outils capables de le faire, tels que PyInstaller, mais ils nécessitent beaucoup de mise en cache pour fonctionner correctement. De plus, il est souvent possible d'extraire le code source d'un programme Python du package généré. Dans certains cas, cela peut être un facteur décisif.

Le projet tiers Nuitka propose une solution radicale. Il compile un programme Python dans un binaire C - non pas en empaquetant le runtime CPython avec le bytecode du programme, mais en traduisant les instructions Python en C. Les résultats peuvent être distribués dans un package compressé ou intégrés dans un programme d'installation avec d'autres produits tiers.

Nuitka essaie également de maintenir une compatibilité maximale avec l'écosystème Python, afin que les bibliothèques tierces comme NumPy puissent fonctionner de manière fiable. Nuitka améliore également les performances des programmes Python compilés dans la mesure du possible, mais encore une fois sans sacrifier la compatibilité globale. Les accélérations ne sont pas garanties, elles varient donc considérablement selon les charges de travail, et certains programmes peuvent ne pas bénéficier d'améliorations significatives des performances. En général, il est préférable de ne pas compter sur Nuitka pour les performances, mais sur une solution groupée.

Installer Nuitka

Nuitka peut être utilisé avec Python 2.6 à 2.7 et Python 3.3 à 3.10. Il peut compiler des binaires pour Microsoft Windows, macOS, Linux et FreeBSD/NetBSD. Il est important de noter que les développeurs doivent créer les binaires sur la plateforme cible ; la compilation croisée n'est pas possible.

Pour chaque plateforme, en plus du runtime Python, un compilateur C est également requis. Sous Microsoft Windows, Visual Studio 2022 ou supérieur est recommandé, mais MinGW-w64 C11 (gcc 11.2 ou supérieur) peut également être utilisé. Pour les autres plateformes, vous pouvez utiliser gcc 5.1 ou supérieur, g++4.4 ou supérieur, clang ou clang cl sous Windows sous Visual Studio.

Il est important de noter que si vous utilisez Python 3.3 ou Python 3.4, Python 2.7 sera requis en raison des dépendances des outils. Tous ces éléments devraient être des raisons d'utiliser la dernière version de Python si vous le pouvez.

Il est préférable d'installer Nuitka dans un environnement virtuel avec votre projet en tant que dépendance de développement plutôt qu'en tant que dépendance de distribution. Nuitka lui-même n'est pas intégré ni utilisé par les projets ; il effectue le regroupement.

Utiliser Nuitka pour la première fois

Après avoir installé Nuitka, utilisez Nuitka ou python-m nuitka pour l'appeler.

La première chose qu'un développeur souhaite faire avec Nuitka est de vérifier que l'ensemble de la chaîne d'outils fonctionne correctement, y compris le compilateur C. Pour tester cela, vous pouvez compiler un simple programme Python "Hello world", nommez-le main.py :

print ("Hello world")

Lors de la compilation d'un programme Python avec Nuitka, passez le nom du module de point d'entrée en argument à Nuitka, Pour exemple Nuitka main.py. Lorsqu'elle est appelée ainsi, Nuitka recevra main.py et construira un exécutable à partir de celui-ci.

Il convient de noter que comme nous testons uniquement les fonctionnalités de Nuitka, il compilera uniquement le fichier Python dans un fichier exécutable. Il ne compile rien d'autre et ne regroupe rien pour la redistribution. Mais compiler un fichier devrait suffire à déterminer si la chaîne d'outils de Nuitka est correctement configurée.

Une fois la compilation terminée, vous devriez voir le fichier exécutable binaire situé dans le même répertoire que le programme Python. Exécutez l'exécutable pour vous assurer qu'il fonctionne correctement.

Il est également possible d'exécuter automatiquement les applications compilées Nuitka en passant --run comme indicateur de ligne de commande.

Si l'exécutable de test "Hello world" fonctionne, vous pouvez essayer de le conditionner sous forme de fichier redistribuable. Ce processus est expliqué ci-dessous.

Il est important de noter que lors de l'exécution de la première compilation de tests à l'aide de Nuitka, cela peut prendre quelques secondes. Et cela ne compile qu'un seul module, pas l'intégralité du programme. La compilation d'un programme complet avec Nuitka peut prendre plusieurs minutes ou plus, selon le nombre de modules utilisés par le programme.

Compilez les programmes Python à l'aide de Nuitka

Par défaut, Nuitka compile uniquement les modules spécifiés. Si le module contient des importations provenant d'ailleurs dans le programme, de la bibliothèque standard ou de packages tiers, vous devez spécifier que ces importations doivent également être compilées.

Considérons un programme "Hello world" modifié avec un module adjacent appelé greet.py :

def greet(name):
print ("Hello ", name)

et un main.py modifié :

import greet
greet.greet("world")

Pour compiler ces deux modules, vous pouvez utiliser le --follow- commutateur d'importations :

nuitka --follow-imports main.py

Ce commutateur garantit que toutes les importations requises par l'ensemble du programme sont suivies à partir de l'instruction d'importation et compilées ensemble.

Une autre option --nofollow-import-to permet d'exclure des sous-répertoires spécifiques du processus d'importation. Cette option est utile pour filtrer les suites de tests ou les modules dont vous savez qu'ils n'ont jamais été utilisés. Il permet également de fournir des caractères génériques comme paramètres.

图1.使用Nuitka编译大型复杂程序。这个示例涉及编译Pyglet模块以及标准库中的许多模块，这需要几分钟的时间

（1）包括动态导入  

现在出现了Python用户在尝试打包Python应用程序以进行分发时经常遇到的问题之一。--follow-imports选项仅遵循通过import语句在代码中显式声明的导入。它不处理动态导入。  

为了解决这个问题，可以使用--include-plugin-directory开关为动态导入的模块提供一个或多个路径。例如，对于包含动态导入代码的名为mods的目录，可以使用：  

nuitka--follow-imports--include-plugin-directory=modsmain.py

（2）包括数据文件和目录  

如果Python程序使用在运行时加载的数据文件，Nuitka也无法自动检测这些文件。要将单个文件和目录包含在Nuitka打包程序中，可能使用--include-data-files和--include-data-dir。  

--include-data-files允许为要复制的文件指定通配符以及要将它们复制到的位置。例如，--include-data dir=/path/to/data=data会将/path.to/data中的所有内容复制到分发目录中的匹配目录数据。

-include-data-dir的工作方式大致相同，只是它不使用通配符；它只允许传递要复制的路径和要将其复制到的分发文件夹中的目标。例如，--include-data dir=/path/to/data=data会将/path.to/data中的所有内容复制到分发目录中的匹配目录数据。

（3）包括Python包和模块  

指定导入的另一种方法是使用Python样式的包命名空间而不是文件路径，使用--include-package选项。例如，以下命令将包括mypackage，它在磁盘上的任何位置（假设Python可以找到它），以及它下面的所有内容：  

nuitka --include-package=mypackage main.py

如果包需要自己的数据文件，可以使用--include-package-data选项包含这些文件：  

nuitka --include-package=mypackage --include-package-data=mypackage main.py

该命令告诉Nuitka获取包目录中实际上不是代码的所有文件。  

如果只想包含单个模块，可以使用--include-module：  

nuitka --include-module=mypackage.mymodule main.py

该命令告诉Nuitka只包含mypackage.mymodule，而不包含其他内容。  

编译Python程序进行重新分发

当想用Nuitka编译Python程序以进行重新分发时，可以使用命令行开关--standalone来处理大部分工作。此开关自动跟随所有导入并生成一个dist文件夹，其中包含已编译的可执行文件和所需的任何支持文件。要重新分发程序，只需要复制此目录即可。  

不要指望--standalone的程序在第一次运行时就可以工作。Python程序的一般动态性几乎保证了需要使用上述其他一些选项来确保编译的程序正常运行。例如，如果有一个需要特定字体的GUI应用程序，可能必须使用--include-data-files或--include-data-dir将它们复制到发行版中。  

此外，如上所述，--standalone应用程序的编译时间可能比测试编译长得多。一旦对测试独立构建的应用程序需要多长时间有所了解，就为测试独立构建的应用程序所需的构建时间进行预算。

最后，Nuitka提供了另一个构建选项--onefile。对于那些熟悉PyInstaller的人来说，--onefile的工作方式与该程序中的相同选项相同：它将整个应用程序（包括其所有依赖文件）压缩为单个可执行文件，无需重新分发其他文件。但是，重要的是要知道--onefile在Linux和Microsoft Windows上的工作方式不同。在Linux上，它使用存档的内容安装一个虚拟文件系统。在Windows上，它会将文件解压缩到一个临时目录中并从那里运行它们，它必须为程序的每次运行执行这一操作。在Windows上使用--onefile可能会显著降低启动程序所需的时间。

原文标题：​​Intro to Nuitka: A better way to compile and distribute Python​​，作者：Serdar Yegulalp

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!