Параметры передачи Python через консоль

Обновлено: 21.11.2024

Запуск скриптов Python из командной строки может стать отличным способом автоматизации рабочих процессов. Для этого вам нужно научиться передавать аргументы из командной строки в сценарий Python. Это позволит вам создавать многократно используемые сценарии, которые можно обновлять или запускать для новых ситуаций или данных, просто передав пару новых аргументов. В Python передать аргументы из командной строки в сценарий очень просто.

Прежде чем вы сможете передавать аргументы сценарию, вам нужно понять, как запускать скрипт Python из командной строки. Следуйте этому пошаговому руководству.

В Python аргументы передаются сценарию из командной строки с помощью пакета sys. Элемент argv sys ( sys.argv ) будет хранить всю информацию в записи командной строки, и к нему можно получить доступ внутри скрипта Python. Модуль Python getopt также можно использовать для разбора именованных аргументов.

Давайте рассмотрим несколько примеров.

Скрипт Python для чтения аргументов командной строки

Для начала мы создадим скрипт, который выводит весь оператор командной строки. Затем мы можем изучить, как передаются аргументы, и узнать, как включить их в наш код.

В скрипте Python мы импортируем sys , а затем просто выводим полное значение sys.argv . Скрипт выглядит следующим образом.

Сохраните этот скрипт как myscript.py . Теперь мы вызовем этот скрипт из командной строки (следуйте этому руководству, если вам нужны инструкции) следующим образом. Убедитесь, что ваш рабочий каталог совпадает с каталогом, в котором находится myscript.py .

Вы заметите, что при вызове скрипта я включил три аргумента, разделенных пробелом (arg1, arg2 и arg3). Это просто для иллюстрации того, как sys хранит и отображает аргументы. Они не имеют никакого значения.

Вот мой вызов myscript.py из командной строки. Вторая строка кода показывает результат.

Вы видите, что sys.argv сохранил аргументы в виде строк в виде списка. Давайте попробуем еще раз с разными типами данных (float, int и string), чтобы посмотреть, как они хранятся.

Вот вызов и вывод скрипта.

Как видите, число с плавающей запятой и целое число также сохранялись в виде строк с помощью sys.argv .

Доступ к аргументам командной строки в скрипте Python

Теперь, когда у нас есть базовая информация о том, как получить доступ к аргументам командной строки и как они хранятся, мы можем начать разбор этих аргументов для использования в нашем скрипте.

В этом простом примере мы перебираем каждый аргумент (кроме первого, который является именем скрипта) и выводим его на консоль.

Начнем с обновления скрипта Python, myscript.py . Мы добавим цикл для перебора последних трех аргументов в sys.argv. Для каждого элемента мы распечатаем его индекс (или позицию) и его значение.

Вот новый скрипт. Обратите внимание, что мы перебираем диапазон, начинающийся с 1. При этом первый аргумент, которым является имя скрипта, пропускается.

Запустите скрипт, используя последний набор аргументов. Вот так.

Вы должны получить вывод, который выглядит следующим образом.

Это дает вам основы передачи аргументов командной строки в сценарий Python. Отсюда вы, вероятно, захотите выполнить некоторые логические проверки, чтобы убедиться, что входные значения являются соответствующими типами и попадают в правильный диапазон или набор значений.

Улучшенный анализ аргументов командной строки Python

В приведенных выше примерах представлены простые примеры, которые помогут вам начать работу. Однако, если вы ищете что-то более продвинутое, позволяющее пользователям указывать аргументы с ключевыми словами и печатать справочные сообщения, нам нужно немного больше.

Чтобы получить именованные аргументы из командной строки, мы будем использовать модуль Python getopt. getopt встроен в базовый Python, поэтому вам не нужно его устанавливать.

Давайте запустим новый скрипт, который использует как sys, так и getopt для разбора аргументов командной строки. Сценарий будет иметь возможность использовать четыре именованных аргумента: «помощь», «ввод», «пользователь» и «вывод». В командной строке эти аргументы можно указать с помощью одного тире и первой буквы (-h) или двойного тире и полного имени аргумента (--help). Назовите этот скрипт myscript2.py .

Этот сценарий будет состоять из двух частей. Первая часть — это функция (myfunc), которая будет принимать аргументы (argv) в качестве входных данных. Вторая часть — это оператор if, который распознает вызов сценария и передает аргументы из sys.argv в myfunc.

В теле myfunc мы определим переменные для ввода, пользователя и вывода. Мы также определим переменную для «помощи» и присвоим ей значение. Переменная help будет распечатана, если возникнет ошибка или если пользователь укажет -h или --help .

Теперь вызовите getopt.getopt и передайте ему аргументы из командной строки, но не имя скрипта (например: argv[1:] ). В вызове getopt мы также указываем как короткое, так и длинное имя параметра.Двоеточие (:) после i , u и o указывает, что для этого параметра требуется значение. Знаки равенства (=) после input , user и output означают одно и то же.

Я поместил вызов getopt.getopt в оператор try exclude, чтобы сценарий распечатывал справочное сообщение, а затем закрывался, если возникнут какие-либо проблемы. Вот как выглядит сценарий на данный момент.

В заключительной части сценария мы проанализируем аргументы на основе их коротких или длинных имен или ключевых слов и распечатаем окончательные значения.

Для начала просмотрите все элементы opts . Это вернет имя аргумента (opt) и значение (arg). Затем используйте оператор if, elif, else, чтобы определить, какой переменной присвоить аргумент. После обработки всех аргументов распечатайте имя аргумента и его значение.

Окончательный сценарий должен выглядеть примерно так.

Давайте воспользуемся этим скриптом несколькими способами, чтобы посмотреть, что получится.

Во-первых, давайте получим справочное сообщение, используя как короткое -h, так и длинное --help имя.

Как и ожидалось, в обоих примерах справочное сообщение выводилось на консоль.

Далее посмотрим, что произойдет, если мы укажем недопустимое имя аргумента --madeup .

Это вызвало ошибку, из-за которой справочное сообщение снова печаталось на консоли.

Теперь давайте введем правильные аргументы.

Аргументы были присвоены соответствующим переменным.

Дальнейшие шаги

Эта статья дает вам базовые сведения о передаче и анализе аргументов командной строки с помощью Python. Для полноценной реализации есть еще много работы, которую вы захотите сделать. Будет важно проверить типы и значения входных аргументов, чтобы убедиться, что они допустимы. Вы также захотите распечатать полезные сообщения для пользователя при возникновении ошибки или другого исключения. Если вы просто реализуете это для личного использования, эти функции не так важны. Я обнаружил, что написание сценариев Python для запуска из командной строки помогло мне автоматизировать многие из моих задач и анализов и сэкономить много времени.

Конрад — специалист по природным ресурсам. Он разрабатывает модели и процессы анализа для прогнозирования и оценки изменений ландшафтов и водных ресурсов.

Последние руководства

Visual Studio Code и Anaconda — это мощные инструменты для разработчиков Python. Однако, если вы пытаетесь использовать Anaconda и Visual Studio Code вместе, есть большая вероятность, что вы столкнулись с некоторыми из них.

QGIS имеет только одну базовую карту, включенную по умолчанию, Open Street Map. Однако у QGIS есть функциональные возможности для поддержки множества различных типов источников и сервисов базовых карт. Базовые карты могут быть.

сообщить об этом объявлении

О нас

Мы считаем, что процедуры обработки данных и аналитики должны повторяться без покупки дорогостоящих лицензий на программное обеспечение. Это возможно с программами с открытым исходным кодом и языками программирования. Наша цель — помочь вам изучить программное обеспечение с открытым исходным кодом и языки программирования для ГИС и науки о данных. Мы делаем это с помощью бесплатных руководств и платных курсов.

сообщить об этом объявлении

сообщить об этом объявлении

У меня есть сценарий. Мне нужно передать значения параметров методам в скрипте и методам для выполнения.

Имя файла app.py

Команда, которую я пытаюсь выполнить: python3 app.py 10 12 method2

В приведенном выше выводе должен быть метод method2(), значение печати равно 12

argv будет ["app.py", "10", "12", "method2"] . поэтому, если вы хотите получить доступ к аргументу «method2», передайте argv[3], а не argv[2]

Вы должны проверить модуль argparse, он довольно прост в использовании и станет удобным, как только у вас будет несколько аргументов командной строки для извлечения

Но мне все еще неясно, чего именно вы пытаетесь достичь. вы пытаетесь выбрать, какую функцию вызывать с помощью аргументов командной строки?

@Tibebes.M В основном мне нужно передать аргумент для выполнения либо функции method1, либо функции method2 отдельно, либо обеих функций. Когда мы передаем аргумент как метод1, он должен выполнять только функцию метода1. Если мы передаем метод 1 и метод 2 в аргументах команды. Он должен выполнять обе функции

2 ответа 2

нет, потому что argv[3] — это строка, а не вызываемый тип. Хотя это не рекомендуется, вы можете получить ссылку на функцию из таблицы поиска, используя locals() или globals()

Вот как вы можете ссылаться на функцию для динамического вызова (из локальной таблицы символов с помощью locals() )

Пояснение: как линия:

работает то, что locals() возвращает тип dict, и мы вызываем метод .get(), чтобы получить ссылку на функцию, которую мы собираемся вызвать (если она не найдена, вместо этого получите функцию method_not_found).

Затем, получив функцию, которую мы хотим вызвать, мы выполняем ее, передавая sys.argv[1], sys.argv[2] в качестве аргументов.

Конечно, можно. local() нужен только для того, чтобы получить ссылку на функцию. последний () — это место, где вы вызываете функцию. просто передайте туда любой аргумент, который вы хотите.

Поскольку Python является таким популярным языком программирования, а также поддерживает большинство операционных систем, он стал широко использоваться для создания инструментов командной строки для многих целей. Эти инструменты могут варьироваться от простых приложений CLI до более сложных, таких как инструмент AWS awscli.

Подобные сложные инструменты обычно управляются пользователем с помощью аргументов командной строки, что позволяет пользователю использовать определенные команды, задавать параметры и т. д. Например, эти параметры могут указывать инструменту на вывод дополнительной информации, чтение данных из указанного источника или отправку вывода в определенное место.

Как правило, аргументы передаются инструментам CLI по-разному, в зависимости от вашей операционной системы:

  • В стиле Unix: - за ней следует буква, например -h , или -- за которой следует слово, например --help
  • Windows: за / следует буква или слово, например /help

Такие разные подходы существуют по историческим причинам. Многие программы в Unix-подобных системах поддерживают как одинарную, так и двойную нотацию тире. Обозначение с одним тире в основном используется с параметрами, состоящими из одной буквы, а двойное тире представляет собой более удобочитаемый список параметров, что особенно полезно для сложных параметров, которые должны быть более явными.

Примечание. В этой статье мы сосредоточимся исключительно на Unix-подобном формате - и -- .

Имейте в виду, что и имя, и значение аргумента специфичны для программы — общего определения нет, кроме нескольких общих соглашений, таких как --help для получения дополнительной информации об использовании инструмента. Как разработчик сценария Python, вы решаете, какие аргументы предоставить вызывающей стороне и что они делают. Это требует надлежащей оценки.

По мере того, как ваш список доступных аргументов будет расти, ваш код будет усложняться, пытаясь точно их проанализировать. К счастью, в Python есть несколько библиотек, которые помогут вам в этом. Мы рассмотрим несколько наиболее распространенных решений, которые варьируются от «сделай сам» с помощью sys.argv до подхода «сделано для вас» с помощью argparse.

Обработка аргументов командной строки с помощью Python

Python 3 поддерживает несколько различных способов обработки аргументов командной строки. Встроенный способ заключается в использовании модуля sys. С точки зрения имен и использования, он напрямую связан с библиотекой C ( libc ). Второй способ — это модуль getopt, который обрабатывает как короткие, так и длинные параметры, включая оценку значений параметров.

Кроме того, существуют два других распространенных метода. Это модуль argparse, производный от модуля optparse, доступного до Python 2.7. Другой метод — использовать модуль docopt, доступный на GitHub.

У каждого из этих способов есть свои плюсы и минусы, поэтому стоит оценить каждый из них, чтобы выбрать наиболее подходящий для вас.

Модуль sys

Это базовый модуль, поставляемый с Python с самого начала. Он использует очень похожий подход к библиотеке C, используя argc / argv для доступа к аргументам. Модуль sys реализует аргументы командной строки в простой структуре списка с именем sys.argv .

Каждый элемент списка представляет один аргумент. Первый элемент в списке, sys.argv[0] — это имя скрипта Python. Остальные элементы списка, от sys.argv[1] до sys.argv[n] , являются аргументами командной строки со 2 по n. В качестве разделителя между аргументами используется пробел. Значения аргументов, содержащие пробелы, должны быть заключены в кавычки, чтобы система sys могла правильно их проанализировать.

Эквивалентом argc является просто количество элементов в списке. Чтобы получить это значение, используйте оператор Python len(). Позже мы покажем это на примере кода.

Печать первого аргумента CLI

В этом первом примере наш скрипт определит, как он был вызван. Эта информация хранится в первом аргументе командной строки с индексом 0.В приведенном ниже коде показано, как получить имя вашего скрипта Python.

Сохраните этот код в файле с именем arguments-program-name.py, а затем вызовите его, как показано ниже. Вывод выглядит следующим образом и содержит имя файла, включая его полный путь:

Как видно из второго вызова выше, мы получаем не только имя файла Python, но и полный путь, используемый для его вызова.

Подсчет количества аргументов

В этом втором примере мы просто подсчитываем количество аргументов командной строки, используя встроенный метод len(). sys.argv — это список, который мы должны изучить. В приведенном ниже коде мы получаем количество аргументов, а затем вычитаем 1, потому что один из этих аргументов (то есть первый) всегда устанавливается как имя файла, что не всегда полезно для нас. Таким образом, фактическое количество переданных пользователем аргументов равно len(sys.argv) - 1 .

Сохраните этот файл и назовите его arguments-count.py. Некоторые примеры вызова этого скрипта показаны ниже. Сюда входят три различных сценария:

  • Вызов без дополнительных аргументов командной строки
  • Вызов с двумя аргументами
  • Вызов с двумя аргументами, где второй – строка в кавычках, содержащая пробел.
Повторение аргументов

В нашем третьем примере выводятся все аргументы, отправленные скрипту Python, за исключением самого имени программы. Поэтому мы перебираем аргументы командной строки, начиная со второго элемента списка. Напомним, что это индекс 1, так как списки в Python основаны на 0.

Ниже мы вызываем наш код, который был сохранен в файл arguments-output.py. Как и в предыдущем примере, выходные данные иллюстрируют три разных вызова:

  • Вызов без аргументов
  • Вызов с двумя аргументами
  • Вызов с двумя аргументами, где второй аргумент представляет собой строку в кавычках, содержащую пробел

Помните, смысл показанного примера строки в кавычках заключается в том, что параметры обычно разделяются пробелом, если только они не заключены в кавычки.

Модуль getopt

Как вы уже могли заметить, модуль sys разбивает строку командной строки только на отдельные аспекты. Модуль Python getopt идет немного дальше и расширяет разделение входной строки с помощью проверки параметров. Основанная на функции C getopt, она допускает использование как коротких, так и длинных опций, включая присвоение значения.

На практике для правильной обработки входных данных требуется модуль sys. Для этого необходимо предварительно загрузить как модуль sys, так и модуль getopt. Далее из списка входных параметров мы удаляем первый элемент списка (см. код ниже), а оставшийся список аргументов командной строки сохраняем в переменной с именем arguments_list .

Бесплатная электронная книга: Git Essentials

Ознакомьтесь с нашим практическим руководством по изучению Git, включающим передовые практики, общепринятые стандарты и памятку. Перестаньте гуглить команды Git и на самом деле изучите их!

Аргументы в списке_аргументов теперь можно анализировать с помощью метода getopts(). Но прежде чем сделать это, нам нужно сообщить getopts() о допустимых параметрах. Они определяются следующим образом:

Это означает, что мы считаем эти аргументы действительными вместе с некоторой дополнительной информацией:

Вы могли заметить, что перед короткой опцией o стояло двоеточие : . Это говорит getopt, что этой опции должно быть присвоено значение.

Теперь это позволяет нам обрабатывать список аргументов. Метод getopt() требует настройки трех параметров: списка фактических аргументов из argv , а также допустимых коротких и длинных параметров (показаны в предыдущем фрагменте кода).

Сам вызов метода хранится в операторе try-catch, чтобы покрыть ошибки во время оценки. Исключение возникает, если обнаруживается аргумент, который не является частью списка, определенного ранее. Сценарий Python выводит сообщение об ошибке на экран и завершает работу с кодом ошибки 2.

Наконец, аргументы с соответствующими значениями сохраняются в двух переменных с именами arguments и values ​​. Теперь вы можете легко оценить эти переменные в своем коде. Мы можем использовать цикл for для перебора списка распознанных аргументов, одна запись за другой.

Ниже вы можете увидеть результат выполнения этого кода. Мы покажем, как программа реагирует как на допустимые, так и на недопустимые аргументы программы:

Последний вызов нашей программы поначалу может показаться немного запутанным. Чтобы понять это, вам нужно знать, что сокращенные опции (иногда также называемые флагами) могут использоваться вместе с одним тире. Это позволяет вашему инструменту легче принимать многие параметры. Например, вызов python arguments-getopt.py -vh аналогичен вызову python arguments-getopt.py -v -h . Таким образом, в последнем вызове выше модуль getopt подумал, что пользователь пытается передать -e в качестве опции, что недопустимо.

Модуль argparse

Модуль argparse доступен начиная с Python 3.2 и является усовершенствованием модуля optparse, существующего до Python 2.7. Документация Python содержит описание API и руководство, в котором подробно рассматриваются все методы.

Модуль предлагает интерфейс командной строки со стандартизированным выводом, в то время как первые два решения оставляют большую часть работы в ваших руках. argparse позволяет проверять фиксированные и необязательные аргументы с проверкой имени как в коротком, так и в длинном стиле. В качестве необязательного аргумента по умолчанию он включает -h вместе с его длинной версией --help . Этот аргумент сопровождается справочным сообщением по умолчанию с описанием принятых аргументов.

В приведенном ниже коде показана инициализация синтаксического анализатора, а приведенный ниже вывод показывает базовый вызов, за которым следует сообщение справки. В отличие от вызовов Python, которые мы использовали в предыдущих примерах, не забывайте использовать Python 3 в этих примерах.

На следующем шаге мы добавим собственное описание в справочное сообщение для наших пользователей. Инициализация синтаксического анализатора таким образом позволяет добавить дополнительный текст. В приведенном ниже коде описание хранится в текстовой переменной, которая явно передается классу argparse в качестве параметра описания. Вызвав этот код ниже, вы можете увидеть, как выглядит результат.

В качестве последнего шага мы добавим необязательный аргумент с именем -V , который имеет соответствующий аргумент длинного стиля с именем --version . Для этого мы используем метод add_argument(), который мы вызываем с тремя параметрами (отображается только для --version ):

  • Имя параметра: --version
  • Текст справки для параметра: help="показать версию программы"
  • Действие (без дополнительного значения): action="store_true"

Исходный код для этого показан ниже. Чтение аргументов в переменную с именем args выполняется с помощью метода parse_args() из объекта парсера. Обратите внимание, что вы отправляете как короткую, так и полную версию за один вызов. Наконец, вы проверяете, установлены ли атрибуты args.V или args.version, и выводите сообщение о версии.

Аргумент --version не требует указания значения в командной строке. Вот почему мы устанавливаем аргумент действия на «store_true». В других случаях вам может понадобиться дополнительное присвоенное значение, например, если вы указываете определенный объем, высоту или ширину. Это показано в следующем примере. Обратите внимание, что по умолчанию все аргументы интерпретируются как строки.

Здесь показано, что происходит при отправке разных значений аргументов. Это включает в себя как короткую, так и полную версию, а также справочное сообщение.

Заключение

В этой статье мы показали множество различных методов получения аргументов командной строки в Python, включая использование sys , getopt и argparse . Эти модули различаются по функциональности, некоторые предоставляют гораздо больше, чем другие. sys является полностью гибким, тогда как для getopt и argparse требуется определенная структура. Напротив, они охватывают большую часть сложной работы, которую sys оставляет за вами. Поработав с предоставленными примерами, вы сможете определить, какой модуль лучше всего подходит для вашего проекта.

В этой статье мы не говорили о других решениях, таких как модуль docopts, мы просто упомянули его. Этот модуль использует совершенно другой подход и будет подробно объяснен в одной из следующих статей.

Аргументы командной строки Python — это параметры, предоставляемые скрипту во время его выполнения. Аргументы командной строки используются для предоставления определенных входных данных программе.

В чем преимущество аргументов командной строки Python?

Аргументы командной строки Python помогают нам сохранять общую природу нашей программы. Например, мы можем написать программу для обработки CSV-файла. Если мы передаем имя CSV-файла из командной строки, наша программа будет работать с любым CSV-файлом. Это сделает нашу программу слабо связанной, и ее будет легко поддерживать.

Еще одним преимуществом аргументов командной строки является дополнительная безопасность. Допустим, у нас есть программа для сохранения данных в базу данных. Если мы храним учетные данные базы данных в скрипте или каком-либо файле конфигурации, к ним может получить доступ и выполнить любой, у кого есть доступ к файлам. Но если пользователь/пароль предоставляется в качестве аргумента командной строки, то его нет в файловой системе, и наша программа более защищена.

Как передать аргументы командной строки в Python?

Если вы запускаете скрипт Python из терминала, просто передайте аргументы после имени скрипта. Аргументы разделяются пробелами.

Передача аргументов командной строки в PyCharm

PyCharm — самая популярная интегрированная среда разработки для программирования на Python. Если вы хотите передать аргументы командной строки программе Python, перейдите в «Выполнить» > «Редактировать конфигурации», установите значение параметров и сохраните его.

Аргументы командной строки Python PyCharm

Как читать аргументы командной строки в скрипте Python?

Существуют три популярных модуля для чтения и разбора аргументов командной строки в сценарии Python.

1. Чтение аргументов командной строки Python с помощью модуля sys

Аргументы командной строки хранятся в переменной argv модуля sys, которая представляет собой список строк. Мы можем прочитать аргументы командной строки из этого списка и использовать его в нашей программе.

Обратите внимание, что имя сценария также является частью аргументов командной строки в переменной sys.argv.

Вывод:

2. Анализ аргументов командной строки с помощью модуля getopt

Модуль Python getopt работает аналогично функции Unix getopt(). Этот модуль полезен, если вы хотите, чтобы сценарий принимал параметры и их значения, подобно многим командам Unix.

Этот модуль работает вместе с sys.argv для анализа аргументов командной строки и извлечения значений параметров в списке кортежей.

Вывод:

3. Разбор аргументов командной строки с помощью модуля argparse

Мы также можем использовать модуль Python argparse для разбора аргументов командной строки. Модуль argparse предоставляет множество возможностей.

  • позиционные аргументы
  • справочное сообщение
  • значение по умолчанию для аргументов
  • указание типа данных аргумента и многое другое.

Вывод:

Обратите внимание, что справочное сообщение автоматически генерируется модулем argparse.

Читайте также: