Créez une application en ligne de commande à l'aide des bibliothèques intégrées Python

PHPz
Libérer: 2023-04-16 22:31:01
avant
818 Les gens l'ont consulté

Créez une application en ligne de commande à l'aide des bibliothèques intégrées Python

Lors de la création d'une application, vous souhaitez généralement pouvoir indiquer à votre application comment faire quelque chose. Il existe deux manières courantes d'accomplir cette tâche : vous pouvez demander à l'application d'accepter les arguments de ligne de commande ou vous pouvez créer une interface utilisateur graphique. Certaines applications prennent en charge les deux.

L'interface de ligne de commande est utile lorsque vous devez exécuter votre code sur le serveur. La plupart des serveurs ne disposent pas d'interface graphique, surtout s'il s'agit de serveurs Linux. Dans ce cas, même si vous souhaitez exécuter l’interface graphique, vous ne pourrez peut-être pas le faire.

Python possède une bibliothèque intégrée appelée argparse qui peut être utilisée pour créer une interface de ligne de commande. Dans cet article, vous apprendrez ce qui suit.

  • Analyser les arguments
  • Créer des informations utiles
  • Ajouter des alias
  • Utiliser des arguments mutuellement exclusifs
  • Créer un outil de recherche simple

Le module argparse offre bien plus que ce qui peut être abordé dans cet article. Si vous souhaitez en savoir plus, vous pouvez consulter la documentation.

Il est maintenant temps de commencer à analyser les paramètres à partir de la ligne de commande.

Parsing Arguments

Avant d'apprendre à utiliser argparse, il est bon de savoir qu'il existe une autre façon de transmettre des paramètres à un script Python. Vous pouvez transmettre n'importe quel paramètre à un script Python et accéder à ces paramètres à l'aide du module sys.

Pour comprendre comment cela fonctionne, créez un fichier appelé sys_args.py et entrez le code suivant :

# sys_args.py import sys def main(): print('You passed the following arguments:') print(sys.argv) if __name__ == '__main__': main()
Copier après la connexion

Ce code importe sys et imprime tout ce qui se trouve dans sys.argv. L'attribut argv contient une liste de tout ce qui est passé au script, le premier élément étant le script lui-même.

Voici un exemple de ce qui se passe lorsque vous exécutez ce code avec quelques paramètres.

$ python3 sys_args.py --s 45 You passed the following arguments: ['sys_args.py', '--s', '45']
Copier après la connexion

Le problème avec l'utilisation de sys.argv est que vous n'avez aucun contrôle sur les arguments qui peuvent être transmis à votre application.

  • Impossible d'ignorer les paramètres
  • Impossible de créer des paramètres par défaut
  • Impossible de savoir quels sont les paramètres valides

C'est pourquoi utiliser argparse est la voie à suivre en utilisant la bibliothèque standard Python. Le module argparse est très puissant et utile. Pensons au processus courant suivi par une application en ligne de commande.

  • pass : transmettre un fichier
  • do : effectuer un traitement sur le fichier dans votre programme
  • output : afficher le résultat

Voici un exemple général de la façon dont cela fonctionne. Allez-y, créez file_parser.py et ajoutez le code suivant.

# file_parser.py import argparse def file_parser(input_file, output_file=''): print(f'Processing {input_file}') print('Finished processing') if output_file: print(f'Creating {output_file}') def main(): parser = argparse.ArgumentParser('File parser') parser.add_argument('--infile', help='Input file') parser.add_argument('--out', help='Output file') args = parser.parse_args() if args.infile: file_parser(args.infile, args.out) if __name__ == '__main__': main()
Copier après la connexion
Copier après la connexion

La fonction file_parser() est la logique d'analyse. Dans cet exemple, il suffit de prendre un nom de fichier et de l'imprimer. La valeur par défaut du paramètre output_file est une chaîne vide.

Le programme se concentre sur main(). Ici, vous créez une instance de argparse.ArgumentParser() et donnez un nom à votre analyseur. Ensuite, vous ajoutez deux paramètres, --infile et --out. Pour utiliser cet analyseur, vous devez appeler parse_args(), qui renverra tous les arguments valides transmis à votre programme. Enfin, vous souhaitez vérifier si l'utilisateur a utilisé l'indicateur --infile. Si tel est le cas, vous exécutez file_parser().

Voici comment exécuter le code dans votre terminal.

$ python file_parser.py --infile something.txt Processing something.txt Finished processing
Copier après la connexion

Ici, vous exécutez votre script avec l'indicateur --infile et un nom de fichier. Cela exécutera main() puis appellera file_parser().

L'étape suivante consiste à essayer d'exécuter votre application en utilisant les deux arguments de ligne de commande que vous avez déclarés dans votre code.

$ python file_parser.py --infile something.txt --out output.txt Processing something.txt Finished processing Creating output.txt
Copier après la connexion

Cette fois, vous obtenez une ligne de sortie supplémentaire mentionnant le nom du fichier de sortie. Cela représente une branche dans la logique de votre code. Lorsque vous spécifiez un fichier de sortie, vous pouvez demander à votre code de générer le fichier à l'aide d'un nouveau bloc de code ou d'une fonction. Si vous ne spécifiez pas de fichier de sortie, ce bloc de code ne s'exécutera pas.

Lorsque vous utilisez argparse pour créer vos outils de ligne de commande, vous pouvez facilement ajouter des informations qui peuvent aider vos utilisateurs lorsqu'ils ne savent pas comment interagir correctement avec votre programme.

Il est maintenant temps de découvrir comment obtenir de l'aide de votre application

Créer un message d'aide

La bibliothèque argparse créera automatiquement un message utile pour votre application en utilisant les informations que vous fournissez lors de la création de chaque argument. Voici le code :

# file_parser.py import argparse def file_parser(input_file, output_file=''): print(f'Processing {input_file}') print('Finished processing') if output_file: print(f'Creating {output_file}') def main(): parser = argparse.ArgumentParser('File parser') parser.add_argument('--infile', help='Input file') parser.add_argument('--out', help='Output file') args = parser.parse_args() if args.infile: file_parser(args.infile, args.out) if __name__ == '__main__': main()
Copier après la connexion
Copier après la connexion

Essayez maintenant d'exécuter ce code avec l'indicateur -h et vous devriez voir ce qui suit. Le paramètre help de

$ file_parser.py -h usage: File parser [-h] [--infile INFILE] [--out OUT] optional arguments: -h, --help show this help message and exit --infile INFILEInput file --out OUTOutput file
Copier après la connexion

add_argument() est utilisé pour créer le message d'aide ci-dessus. argparse ajoute automatiquement les options -h et -help. Vous pouvez rendre votre aide informative en lui donnant une description et un post-scriptum.

Laissez-nous les utiliser pour améliorer vos messages d'aide. Tout d'abord, copiez le code ci-dessus dans un nouveau fichier, nommez-le file_parser_with_description.py, puis modifiez-le pour qu'il ressemble à ci-dessous.

# file_parser_with_description.py import argparse def file_parser(input_file, output_file=''): print(f'Processing {input_file}') print('Finished processing') if output_file: print(f'Creating {output_file}') def main(): parser = argparse.ArgumentParser( 'File parser', description='PyParse - The File Processor', epilog='Thank you for choosing PyParse!', ) parser.add_argument('--infile', help='Input file for conversion') parser.add_argument('--out', help='Converted output file') args = parser.parse_args() if args.infile: file_parser(args.infile, args.out) if __name__ == '__main__': main()
Copier après la connexion

Ici, transmettez les paramètres de description et d'épilogue à ArgumentParser. J'ai également mis à jour l'argument d'aide pour add_argument() pour qu'il soit plus descriptif.

Après avoir effectué ces modifications, lorsque vous exécutez ce script avec -h ou --help, vous verrez le résultat suivant.

$ python file_parser_with_description.py -h usage: File parser [-h] [--infile INFILE] [--out OUT] PyParse - The File Processor optional arguments: -h, --help show this help message and exit --infile INFILEInput file for conversion --out OUTConverted output file Thank you for choosing PyParse!
Copier après la connexion

现在可以在你的帮助输出中看到新的description 和epilog。这给了你的命令行程序一些额外的修饰。

你也可以通过ArgumentParser的 add_help参数在你的应用程序中完全禁用帮助。如果你认为你的帮助文本过于冗长,你可以像这样禁用它。

# file_parser_no_help.py import argparse def file_parser(input_file, output_file=''): print(f'Processing {input_file}') print('Finished processing') if output_file: print(f'Creating {output_file}') def main(): parser = argparse.ArgumentParser( 'File parser', description='PyParse - The File Processor', epilog='Thank you for choosing PyParse!', add_help=False, ) parser.add_argument('--infile', help='Input file for conversion') parser.add_argument('--out', help='Converted output file') args = parser.parse_args() if args.infile: file_parser(args.infile, args.out) if __name__ == '__main__': main()
Copier après la connexion

通过将 add_help设置为 False,你将禁用 -h和 --help标志。

你可以看到下面的演示。

$ python file_parser_no_help.py --help usage: File parser [--infile INFILE] [--out OUT] File parser: error: unrecognized arguments: --help
Copier après la connexion

在下一节中,你将学习如何为你的参数添加别名!

添加别名

别名是一个花哨的词,指的是使用一个替代的标志来做同样的事情。例如,你知道你可以使用 -h和 --help来访问程序的帮助信息。-h是 --help的别名,反之亦然。

看看 main()里面的 parser.add_argument()方法有什么变化。

# file_parser_aliases.py import argparse def file_parser(input_file, output_file=''): print(f'Processing {input_file}') print('Finished processing') if output_file: print(f'Creating {output_file}') def main(): parser = argparse.ArgumentParser( 'File parser', description='PyParse - The File Processor', epilog='Thank you for choosing PyParse!', add_help=False, ) parser.add_argument('-i', '--infile', help='Input file for conversion') parser.add_argument('-o', '--out', help='Converted output file') args = parser.parse_args() if args.infile: file_parser(args.infile, args.out) if __name__ == '__main__': main()
Copier après la connexion

这里你改变了第一个 add_argument(),除了接受 -infile之外,还接受了 -i,你还在第二个 add_argument()中加入了 -o。这样就可以使用两个新的快捷标志来运行你的代码。

下面是一个例子。

$ python3 file_parser_aliases.py -i something.txt -o output.txt Processing something.txt Finished processing Creating output.txt
Copier après la connexion

如果你去看argparse文档,你会发现也可以给子解析器添加别名。子解析器是一种在你的应用程序中创建子命令的方法,这样它就可以做其他事情。一个很好的例子是Docker,一个虚拟化或容器应用程序。它有一系列的命令,你可以在docker下运行,以及docker compose等等。这些命令中的每一个都有独立的子命令,你都可以使用。

下面是一个典型的docker命令,用于运行一个容器。

docker exec -it container_name bash
Copier après la connexion

这将用docker启动一个容器。而如果你要使用docker compose,你将使用一组不同的命令。exec和compose是subparsers的例子。

使用相互排斥的参数

有时你需要让你的应用程序接受一些参数,但不接受其他参数。例如,你可能想限制你的应用程序,使它只能创建或删除文件,而不是同时创建和删除。

argparse模块提供了 add_mutually_exclusive_group()方法,它就是这样做的。

将你的两个参数添加到一个组对象中,使其相互排斥,如下面的例子。

# file_parser_exclusive.py import argparse def file_parser(input_file, output_file=''): print(f'Processing {input_file}') print('Finished processing') if output_file: print(f'Creating {output_file}') def main(): parser = argparse.ArgumentParser( 'File parser', description='PyParse - The File Processor', epilog='Thank you for choosing PyParse!', add_help=False, ) group = parser.add_mutually_exclusive_group() group.add_argument('-i', '--infile', help='Input file for conversion') group.add_argument('-o', '--out', help='Converted output file') args = parser.parse_args() if args.infile: file_parser(args.infile, args.out) if __name__ == '__main__': main()
Copier après la connexion

首先,你创建了一个相互排斥的组。然后,你把 -i和 -o参数添加到组中,而不是添加到解析器对象中。现在这两个参数是互斥的。

下面是当你试图用这两个参数运行你的代码时发生的情况。

$ python3 file_parser_exclusive.py -i something.txt -o output.txt usage: File parser [-i INFILE | -o OUT] File parser: error: argument -o/--out: not allowed with argument -i/--infile
Copier après la connexion

用这两个参数运行你的代码,会使你的解析器向用户显示一条错误信息,解释他们做错了什么。

在涵盖了所有这些与使用argparse有关的信息之后,你已经准备好应用你的新技能来创建一个简单的搜索工具了

创建一个简单的搜索工具

在开始创建一个应用程序之前,弄清楚你要完成的任务总是好的。你在本节中想要建立的应用程序应该能够搜索特定文件类型的文件。为了使它更有趣,你可以添加一个额外的参数,让你也能选择性地搜索特定的文件大小。

你可以使用 Python 的 glob 模块来搜索文件类型。你可以在这里阅读关于这个模块的所有信息。

https://docs.python.org/3/library/glob.html
Copier après la connexion

还有一个 fnmatch 模块,glob 自己也使用它。你现在应该使用 glob,因为它更容易使用,但是如果你有兴趣写一些更专业的东西,那么 fnmatch 可能是你正在寻找的。

然而,由于你希望能够通过文件大小来选择性地过滤返回的文件,你可以使用 pathlib,它包括一个类似 glob 的接口。glob 模块本身并不提供文件大小的信息。

你可以先创建一个名为 pysearch.py 的文件并输入以下代码。

# pysearch.py import argparse import pathlib def search_folder(path, extension, file_size=None): """ Search folder for files """ folder = pathlib.Path(path) files = list(folder.rglob(f'*.{extension}')) if not files: print(f'No files found with {extension=}') return if file_size is not None: files = [ f for f in files if f.stat().st_size >= file_size ] print(f'{len(files)} *.{extension} files found:') for file_path in files: print(file_path)
Copier après la connexion

在上面的代码片段中,首先导入了argparse和pathlib。接下来,创建了search_folder()函数,它接收了三个参数。

  • path - 要搜索的文件夹
  • extension - 要寻找的文件扩展名
  • file_size - 要过滤的文件大小,以字节为单位。

把路径变成pathlib.Path对象,然后使用其rglob()方法在文件夹中搜索用户传入的扩展名。如果没有找到文件,就向用户打印一个有意义的信息,然后退出。

如果找到了任何文件,就检查是否已经设置了filesize。如果它被设置了,就用一个list comprehension来过滤出小于指定的filesize的文件。

接下来,打印出找到的文件的数量,最后在这些文件上循环,打印出它们的名字。

为了使这一切正常工作,需要创建一个命令行界面。你可以通过添加一个包含argparse代码的main()函数来做到这一点,像这样。

def main(): parser = argparse.ArgumentParser( 'PySearch', description='PySearch - The Python Powered File Searcher', ) parser.add_argument('-p', '--path', help='The path to search for files', required=True, dest='path') parser.add_argument('-e', '--ext', help='The extension to search for', required=True, dest='extension') parser.add_argument('-s', '--size', help='The file size to filter on in bytes', type=int, dest='size', default=None) args = parser.parse_args() search_folder(args.path, args.extension, args.size) if __name__ == '__main__': main()
Copier après la connexion

这个ArgumentParser()有三个参数,与你传递给search_folder()的参数相对应。让--path和--ext参数成为必需的,而让--size参数成为可选的。注意,--size参数被设置为type=int,这意味着你不能把它传成字符串。

add_argument()函数有一个新的参数。它是dest参数,可以用它来告诉你的参数分析器在哪里保存传递给它们的参数。

下面是一个脚本运行的例子。

$ python3 pysearch.py -p /Users/michael/Dropbox/python101code/chapter32_argparse -e py -s 650 6 *.py files found: /Users/michael/Dropbox/python101code/chapter32_argparse/file_parser_aliases2.py /Users/michael/Dropbox/python101code/chapter32_argparse/pysearch.py /Users/michael/Dropbox/python101code/chapter32_argparse/file_parser_aliases.py /Users/michael/Dropbox/python101code/chapter32_argparse/file_parser_with_description.py /Users/michael/Dropbox/python101code/chapter32_argparse/file_parser_exclusive.py /Users/michael/Dropbox/python101code/chapter32_argparse/file_parser_no_help.py
Copier après la connexion

现在试试用-s和一个字符串来运行它。

$ python3 pysearch.py -p /Users/michael/Dropbox/python101code/chapter32_argparse -e py -s python usage: PySearch [-h] -p PATH -e EXTENSION [-s SIZE] PySearch: error: argument -s/--size: invalid int value: 'python'
Copier après la connexion

这次我们收到了一个错误,因为-s和-size只接受整数。在你自己的机器上运行一下这段代码,看看当你使用-s和整数时,它是否按你想要的方式工作。

这里有一些想法,你可以用来改进你的代码版本。

更好地处理扩展文件。现在,它将接受 *.py,这不会像你期望的那样工作。

更新代码,以便你可以一次搜索多个扩展名

更新代码,以便对文件大小的范围进行过滤(例如,1MB-5MB)。

还有很多其他的功能和改进,你可以添加到这个代码中,比如添加错误处理或单元测试。

总结

argparse模块功能齐全,可以用来创建庞大、灵活的命令行应用程序。在本章中,你了解了以下内容。

  • 解析参数
  • 创建有用的信息
  • 添加别名
  • 使用相互排斥的参数
  • 创建一个简单的搜索工具

你可以用argparse模块做更多的事情,不完全包括本章所讲的。请务必查看文档以了解全部细节。现在去试试吧。你会发现,一旦你掌握了使用argparse的窍门,你就可以创建一些非常整洁的应用程序了。

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!

Étiquettes associées:
source:51cto.com
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!