Un outil pour implémenter des programmes de packaging par lots en utilisant Python~

Récemment, j'ai lu quelques articles sur l'outil d'empaquetage visuel auto-py-to-exe publié par certains grands. Auto-py-to-exe est basé sur pyinstaller, mais comparé à pyinstaller, il possède une interface graphique supplémentaire. . Je l'ai également essayé moi-même et je l'ai trouvé vraiment utile et pratique. Vous pouvez empaqueter le programme en quelques clics.

Mais j'ai découvert que ni auto-py-to-exe ni pyinstaller ne peuvent directement empaqueter plusieurs programmes à la fois. Si vous souhaitez empaqueter plusieurs programmes, vous devez le refaire, donc pour un programmeur, c'est une chose intolérable. . Sur cette base, j'ai écrit un petit programme de packaging par lots basé sur pyinstaller.

Le programme appelle la commande cmd

Le programme d'empaquetage pyinstaller doit utiliser la commande cmd. Voici une brève introduction aux méthodes courantes d'appel de la commande cmd.

os.system()

system() est une fonction intégrée au module os, qui peut convertir une chaîne en commande et l'exécuter sur le terminal :

def system(*args, **kwargs): # real signature unknown
 """ Execute the command in a subshell. """
 pass

Utiliser cette méthode est très simple, il suffit de convertir la commande à exécuter sous forme de chaîne Il suffit de le mettre dans la fonction :

import os
os.system(f'pyinstaller -F -w D:程序.py')

La fenêtre cmd n'apparaîtra pas lors de l'exécution de la commande. Elle sera affichée dans l'EDI par défaut. Le fichier généré sera dans le même répertoire par défaut :

.

Méthode os.popen()

popen() C'est également une fonction intégrée du module os, implémentée via des pipelines. La valeur de retour est un objet fichier qui peut être lu et écrit. La valeur par défaut est la lecture « r ». Le contenu de sortie peut être lu en appelant la méthode read() ou readlines() de l'objet. Voici le code source :

def popen(cmd, mode="r", buffering=-1):
 if not isinstance(cmd, str):
 raise TypeError("invalid cmd type (%s, expected string)" % type(cmd))
 if mode not in ("r", "w"):
 raise ValueError("invalid mode %r" % mode)
 if buffering == 0 or buffering is None:
 raise ValueError("popen() does not support unbuffered streams")
 import subprocess, io
 if mode == "r":
 proc = subprocess.Popen(cmd,
 shell=True,
 stdout=subprocess.PIPE,
 bufsize=buffering)
 return _wrap_close(io.TextIOWrapper(proc.stdout), proc)
 else:
 proc = subprocess.Popen(cmd,
 shell=True,
 stdin=subprocess.PIPE,
 bufsize=buffering)
 return _wrap_close(io.TextIOWrapper(proc.stdin), proc)

L'utilisation doit simplement transmettre les paramètres nécessaires et s'exécuter en lecture ou en écriture :

os.popen(f'pyinstaller -F -w D:程序.py').read()

Le résultat de l'exécution est le même que celui de os. Comme .system(), les fichiers générés sont dans le même répertoire.

subprocess.run()

Le module subprocess est officiellement utilisé pour remplacer certaines anciennes méthodes de module. Il contient de nombreuses méthodes de contenu et est plus complet que os.system() et os.popen(). Le module subprocess dispose de plusieurs méthodes pour appeler les commandes cmd, à savoir Popen, call, run et getstatusoutput. Ici, nous expliquons seulement brièvement la méthode run(). La fonction

subprocess.run() exécute la commande spécifiée, attend que la commande soit exécutée et renvoie une instance de la classe CompletedProcess contenant le résultat de l'exécution.

L'utilisation est la même que celle des méthodes os.system() et os.popen(), en passant la commande string, mais la sélection des paramètres est bien plus comparée à os.system() et os.popen() :

subprocess.run(f'pyinstaller -F -w D:程序.py')

La méthode ne renvoie pas de sortie par défaut, uniquement la commande et l'état d'exécution.

Mise en œuvre du programme

Nous savons déjà comment plusieurs programmes appellent des commandes cmd. Cet article utilise la méthode os.system(). Les méthodes d'utilisation sont très simples. Si les exigences sont plus complexes, vous pouvez effectuer des recherches approfondies.

La bibliothèque utilisée pour construire l'interface graphique est PySimpleGUI :

import os
import PySimpleGUI as sg

Si elle n'a pas encore été installée, vous pouvez utiliser la commande pip pour l'installer :

pip intsall 库名

Conception de l'interface GUI

Parce qu'il n'y a pas d'exigences particulières pour les fonctions, il suffit de pouvoir le conditionner en une seule opération. Plusieurs programmes suffisent, et le code de conception final est le suivant :

# 主题设置
sg.theme('LightBrown3')
# 布局设置
layout = [
 [sg.Frame(layout=[
 [
 sg.InputText(key='please_select_file', size=(24, 1), font=("微软雅黑", 10), enable_events=True),
 # FileBrowse 只能选择单个文件 FilesBrowse加入s可以选择多个文件
 sg.FilesBrowse('获取文件', file_types=(("Text Files", "*.py"),), font=("微软雅黑", 10)),
 ],
 ],
 title='选择文件', title_color='blue', font=("微软雅黑", 10), relief=sg.RELIEF_SUNKEN, )],
 [sg.Button('开始打包', font=("微软雅黑", 10)),
sg.Text('', font=("微软雅黑", 10), size=(16, 0)), sg.Button('退出程序', font=("微软雅黑", 10), button_color='red')]# button_color blue red
]
# 创建窗口
window = sg.Window('打包工具', layout, font=("微软雅黑", 12), default_element_size=(30, 1))

L'interface est la suivante :

Interface du widget

Conception logique

Le les chemins de fichiers obtenus via l'interface sont séparés par ";" et doivent être divisés ultérieurement ：

valuelist = []
# 事件循环
while True:
 # 退出按钮
 event, values = window.read()
 if event in (None, '退出程序'):
 break
 # 打开文件按钮
 if event == 'please_select_file':
 fileName = values['please_select_file']
 # 得到的文件路径是以 “；”相分隔的，传入列表
 valuelist.append(fileName)
 if event == '开始打包':
 if len(valuelist) != 0:
# 传入打包函数
 pyinstaller_(valuelist)
 else:
 sg.popup('文件未选择！')

Fonction d'emballage

La fonction reçoit une liste, qui doit être lue dans une boucle ; , qui doit encore être lu en boucle ; l'effet d'empaquetage du programme est relativement simple, -F et -w génèrent respectivement un seul fichier exécutable et annulent l'affichage de la fenêtre de ligne de commande :

def pyinstaller_(valuelist):
 for i in valuelist:
 a = i.split(';')
 for x in a:
 os.system(f'pyinstaller -F -w {x}')

Les fichiers exécutables .exe générés finaux sont enregistrés dans le fichier dist :

Le fichier .exe résultat

du gadget Avantages et inconvénients :

• Avantages : L'effet du gadget n'est pas très utile pour les personnes ayant d'autres besoins, mais il l'est quand même utile pour les personnes qui ont besoin de regrouper plusieurs programmes. Après tout, les opérations répétées doivent être refusées.
• Inconvénients : les défauts du gadget sont évidents. Il ne peut pas fonctionner sur les icônes de programmes packagés, etc., et lors de l'exécution de commandes, il ne peut être exécuté qu'une par une, ce qui réduit considérablement l'efficacité et nécessite la coordination des threads et des processus.

À ce stade, nous avons utilisé avec succès Python pour résoudre le besoin de packaging par lots de programmes et nous avons libéré les mains.

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!