Меню

Python shell не работает

Запуск Python и python-скрипт на компьютере

Код, написанный на языке Python, может храниться в редакторе кода, IDE или файле. И он не будет работать, если не знать, как его правильно запускать.

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

Где запускать Python-скрипты и как?

Python-код можно запустить одним из следующих способов:

  1. С помощью командной строки операционной системы (shell или терминал);
  2. С помощью конкретной версии Python или Anaconda;
  3. Использовать Crontab;
  4. Запустить код с помощью другого Python-скрипта;
  5. С помощью файлового менеджера;
  6. Использовать интерактивный режим Python;
  7. Использовать IDE или редактор кода.

Запуск Python-кода интерактивно

Для запуска интерактивной сессии нужно просто открыть терминал или командную строку и ввести python (или python3 в зависимости от версии). После нажатия Enter запустится интерактивный режим.

Вот как запустить интерактивный режим в разных ОС.

Интерактивный режим в Linux

Откройте терминал. Он должен выглядеть приблизительно вот так :

После нажатия Enter будет запущен интерактивный режим Python.

Интерактивный режим в macOS

На устройствах с macOS все работает похожим образом. Изображение ниже демонстрирует интерактивный режим в этой ОС.

Интерактивный режим в Windows

В Windows нужно открыть командную строку и ввести python . После нажатия Enter появится приблизительно следующее:

Запуск Python-скриптов в интерактивном режиме

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

Этот код должен выводить целые числа от 0 до 5. В данном случае вывод — все, что появилось после print(i) .

Для выхода из интерактивного режима нужно написать следующее:

И нажать Enter. Вы вернетесь в терминал, из которого и начинали.

Есть и другие способы остановки работы с интерактивным режимом Python. В Linux нужно нажать Ctrl + D, а в Windows — Ctrl + Z + Enter.

Стоит отметить, что при использовании этого режима Python-скрипты не сохраняются в локальный файл.

Как выполняются Python-скрипты?

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

При запуске скрипта интерпретатор Python проходит сверху вниз, выполняя каждую из них. Именно таким образом происходит выполнение кода.

Но и это еще не все.

Блок-схема выполнения кода интерпретатором

  • Шаг 1: скрипт или .py-файл компилируется, и из него генерируются бинарные данные. Готовый файл имеет расширение .pyc или .pyo.
  • Шаг 2: генерируется бинарный файл. Он читается интерпретатором для выполнения инструкций.

Это набор инструкций, которые приводят к финальному результату.

Иногда полезно изучать байткод. Если вы планируете стать опытным Python-программистом, то важно уметь понимать его для написания качественного кода.

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

Как запускать Python-скрипты?

Для запуска Python-скрипта с помощью командной строки сначала нужно сохранить код в локальный файл.

Возьмем в качестве примера файл, который был сохранен как python_script.py. Сохранить его можно вот так:

  • Создать Python-скрипт из командной строки и сохранить его,
  • Создать Python-скрипт с помощью текстового редактора или IDE и сохранить его. Просто создайте файл, добавьте код и сохраните как «python_script.py»

Сохранить скрипт в текстовом редакторе достаточно легко. Процесс ничем не отличается от сохранения простого текстового файла.

Но если использовать командную строку, то здесь нужны дополнительные шаги. Во-первых, в самом терминале нужно перейти в директорию, где должен быть сохранен файл. Оказавшись в нужной папке, следует выполнить следующую команду (на linux):

После нажатия Enter откроется интерфейс командной строки, который выглядит приблизительно следующим образом:

Теперь можно писать код и с легкостью сохранять его прямо в командной строке.

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

Скрипты можно запустить и с помощью команды Python прямо в интерфейсе терминала. Для этого нужно убедиться, что вы указали путь до него или находитесь в той же папке. Для выполнения скрипта (python_script.py) откройте командную строку и напишите python3 python_script.py .

Замените python3 на python , если хотите использовать версию Python2.x.

Источник

Выполнение shell команд с Python

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

Читайте также:  Почему не работает приложение самокат

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

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

Использование os.system для запуска команды

Python позволяет нам немедленно выполнить команду оболочки, которая хранится в строке, используя функцию os.system() .

Давайте начнем с создания нового файла Python с именем echo_adelle.py и введите следующее:

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

В вашем терминале запустите этот файл с помощью следующей команды, и вы должны увидеть соответствующий вывод:

По мере того, как команды echo выводятся в наш stdout , os.system() также возвращает код завершения команды оболочки. Код 0 означает, что он работает без проблем, а любое другое число означает ошибку.

Давайте создадим новый файл с именем cd_return_codes.py и введите следующее:

В этом сценарии мы создаем две переменные, в которых хранятся результаты выполнения команд, которые изменяют каталог на домашнюю папку и на несуществующую папку. Запустив этот файл, мы увидим:

Первая команда, которая изменяет каталог на домашний каталог, выполняется успешно. Следовательно, os.system() возвращает код ноль, который хранится в home_dir . С другой стороны, unknown_dir сохраняет код завершения неудачной команды bash, чтобы изменить каталог на несуществующую папку.

Функция os.system() выполняет команду, печатает любой вывод команды на консоль и возвращает код завершения команды. Если нам нужно более детальное управление вводом и выводом команды оболочки в Python, мы должны использовать модуль subprocess .

Выполнение команды с подпроцессом

Модуль subprocess — это рекомендуемый Python способ выполнения команд оболочки. Это дает нам гибкость для подавления вывода команд оболочки или цепочки входов и выходов различных команд вместе, в то же время обеспечивая аналогичный опыт os.system() для базовых сценариев использования.

В новом файле с именем list_subprocess.py напишите следующий код:

В первой строке мы импортируем модуль subprocess , который является частью стандартной библиотеки Python. Затем мы используем функцию subprocess.run() для выполнения команды. Также как и команда os.system() , subprocess.run() возвращает код того, что было выполнено.

Обратите внимание, что subprocess.run() принимает список строк в качестве входных данных вместо одной строки. Первым элементом списка является название команды. Остальные пункты списка — это флаги и аргументы команды.

Примечание: Как правило, вам нужно отделить аргументы , основанные на пространстве, например , ls -alh будет [«ls», «-alh»] , а ls -a -l -h , превратится в [«ls», «-a», -«l», «-h»] .

Запустите этот файл, и вывод вашей консоли будет похож на:

Теперь давайте попробуем использовать одну из более продвинутых функций subprocess.run() , а именно игнорирование вывода в stdout . В том же файле list_subprocess.py измените:

Стандартный вывод команды теперь передается на специальное устройство /dev/null , что означает, что вывод не будет отображаться на наших консолях. Запустите файл в вашей оболочке, чтобы увидеть следующий вывод:

Что если мы хотим получить результат команды? subprocess.run() поможет сделать это. Создайте новый файл с именем cat_subprocess.py , набрав следующее:

Мы используем довольно много параметров, давайте рассмотрим их:

  1. stdout=subprocess.PIPE говорит Python перенаправить результат выполнения команды в объект, чтобы позже его можно было прочитать вручную
  2. text=True возвращает stdout и в stderr виде строк. Тип возвращаемого значения по умолчанию — байты.
  3. input=»Hello from the other side» говорит Python добавить строку в качестве ввода в команду cat .

Запуск этого файла приводит к следующему выводу:

Мы также можем бросить Exception без проверки значения возврата. В новом файле false_subprocess.py добавьте код ниже:

В вашем терминале запустите этот файл. Вы увидите следующую ошибку:

Читайте также:  Ответственность за то что не работаешь

Используя check=True , мы сообщаем Python, что нужно вызывать любые исключения, если возникает ошибка. Так как мы столкнулись с ошибкой, оператор print в последней строке не был выполнен.

Функция subprocess.run() дает нам огромную гибкость. Эта функция представляет собой упрощенную абстракцию класса subprocess.Popen , которая предоставляет дополнительные функциональные возможности, которые мы можем исследовать.

Выполнение команды с Popen

Класс subprocess.Popen предоставляет больше возможностей для разработчика при взаимодействии с оболочкой. Тем не менее, мы должны быть более точными в получении результатов и ошибок

По умолчанию subprocess.Popen не останавливает обработку программы Python, если ее команда не завершила выполнение. В новом файле с именем list_popen.py введите следующее:

Этот код эквивалентен list_subprocess.py . Он запускает команду с помощью subprocess.Popen и ожидает ее завершения, прежде чем выполнить оставшуюся часть сценария Python.

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

Метод poll() возвращает код завершения, если команда закончит работу, или None если он все еще выполняется. Например, если бы мы хотели проверить, завершено ли list_dir , а не ждать его, у нас была бы следующая строка кода:

Для управления вводом и выводом subprocess.Popen нам нужно использовать метод communicate() .

В новый файл с именем cat_popen.py добавьте следующий фрагмент кода:

Метод communicate() принимает аргумент input , который используется для передачи входных данных команде оболочки. Метод communicate также возвращает stdout и stderr когда они установлены.

Мы рассмотрели три способа запуска команд оболочки в Python с использованием класса subprocess.Popen . Давайте еще раз рассмотрим их характеристики, чтобы узнать, какой метод лучше всего подходит для требований проекта.

Какой из них я должен использовать?

Если вам нужно выполнить одну или несколько простых команд и вам не помешает, если их вывод поступит в консоль, вы можете использовать команду os.system() . Если вы хотите управлять вводом и выводом команды оболочки, используйте subsystem.run() . Если вы хотите выполнить команду и продолжить выполнять другую работу, пока она выполняется, используйте subprocess.Popen .

Вот таблица с некоторыми различиями в юзабилити, которые вы также можете использовать для обоснования своего решения:

Источник

Сдруживаем Python и Bash: библиотеки smart-env и python-shell

Доброго времени суток всем.

На сегодняшний день Python является одним из наиболее используемых языков в сфере создания не только непосредственно программных продуктов, но также обеспечения их инфраструктуры. Вследствие этого многим девопсам, по их воле или против оной, пришлось учить новый язык для последующего использования в качестве дополнения к старым добрым Bash-скриптам. Однако Bash и Python исповедуют различные подходы к написанию кода и имеют определенные особенности, в виду чего портирование Bash-скриптов на «змеиный язык» иногда оказывается ёмкой и далеко не тривиальной задачей.

Чтобы упростить жизнь девопсам, создано и продолжает создаваться много полезных библиотек и утилит на Python. Данная статья описывает сразу две новых библиотеки, созданные автором сего поста — smart-env и python-shell — и призванные избавить девопса от необходимости уделять много внимания тонкостям работы с Python, оставляя простор для более интересных задач. Сфера деятельности библиотек — переменные окружения и запуск внешних утилит.

Кого заинтересовало, прошу под кат.

Новые «велосипеды»?

Казалось бы, зачем создавать новые пакеты для достаточно обыденных операций? Что мешает использовать напрямую os.environ и subprocess. ?

Доказательства в пользу каждой из библиотек приведу отдельно.

Библиотека smart-env

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

По результатам поиска было выявлено следующее:

  • есть пакеты, действительно оборачивающие вызовы к os.environ, однако при этом требующие кучу отвлекающих действий (создание экземпляра класса, спец-параметры в вызовах и пр.);
  • есть неплохие пакеты, которые, однако, жестко завязаны на определенную экосистему (в основном, на веб-фреймворки вроде Django) и потому без напильника совсем не универсальные;
  • есть редкие попытки сделать что-то новое. Например, добавить типизацию и явно парсить значения переменных путем вызова методов вида

Или вот еще одно решение, которое, однако, не поддерживает ныне опальный Python 2 (на котором, несмотря на официальный R.I.P., все еще остаются горы написанного кода и целые экосистемы);

  • есть школьно-студенческие поделки, вообще непонятно зачем оказавшиеся в апстримном PyPI и только создающие проблемы с именованием новых пакетов (в частности, название «smart-env» — вынужденная мера).
  • И этот список можно продолжать долго. Однако и приведенных выше пунктов хватило, чтобы загореться идеей сделать нечто удобное и универсальное.

    Требования, которые ставились перед написанием smart-env:

    • Максимально простая схема использования
    • Легко конфигурируемая поддержка типизации данных
    • Совместимость с Python 2.7
    • Хорошее покрытие кода тестами

    В конечном итоге, все это удалось реализовать. Вот пример использования:

    Как видно из примера, для работы с новым классом достаточно его импортировать (создавать экземпляр не нужно — минус лишнее действие). Доступ к любой переменной окружения достигается путем обращения к ней как к переменной класса ENV, что, фактически, делает этот класс интуитивно понятной обёрткой нативного системного окружения, параллельно превращая его в возможный вариант объекта конфигурации практически любой системы (похожий подход, например, достигается в Django, только там конфигурационным объектом выступает непосредственно модуль/пакет settings).

    Включение/выключение режима поддержки автоматической типизации достигается использованием двух методов — enable_automatic_type_cast() и disable_automatic_type_cast(). Это может быть удобно, если в переменной окружения лежит сериализованный JSON-подобный объект или даже просто булевая константа (явное прописывание переменной DEBUG в Django путем сравнения переменной окружения с «допустимыми» строками — один из часто встречающихся случаев). Но теперь нет нужды явно конвертировать строки — большая часть необходимых действий уже заложена в недрах библиотеки и только ждет сигнала к действию. 🙂 В целом же типизация работает прозрачно и поддерживает почти все имеющиеся встроенные типы данных (не тестировались frozenset, complex и bytes).

    Требование поддержки Python 2 было реализовано практически без жертв (отказ от typing и некоторых «сахарных конфеток» последних версий Python 3), в частности, благодаря вездесущему six (для решения проблем использования метаклассов).

    Но есть и немного ограничений:

    • Поддержка Python 3 подразумевает версию 3.5 и выше (их наличие в вашем проекте — результат либо лени, либо отсутствия необходимости в улучшениях, т.к. сложно придумать объективную причину, почему вы до сих пор сидите на 3.4);
    • В Python 2.7 библиотека не поддерживает десериализацию литералов множеств. Описание тут. Но, если кто-нибудь захочет реализовать — welcome:);

    Библиотека также исповедует механизм исключений на случай ошибок парсинга. Если строку не удалось распознать ни одним из имеющихся анализаторов, значение остается строковым (скорее, из соображений удобства и обратной совместимости с привычной логикой работы переменных в Bash).

    Библиотека python-shell

    Теперь расскажу о второй библиотеке (описание недостатков имеющихся аналогов опущу — оно похоже на описанное для smart-env. Аналоги — тут и тут).

    В целом, идея реализации и требования к ней аналогичны описанным для smart-env, что видно из примера:

    1. Единый класс, олицетворяющий Bash в мире Python;
    2. Каждая Bash-команда вызывается как функция класса Shell;
    3. Параметры вызова каждой функции далее пробрасываются в вызов соответствующей команды Bash;
    4. Каждая команда выполняется «здесь и сейчас» в момент ее вызова, т.е. работает синхронный подход;
    5. есть возможность получить доступ к выхлопу команды в stdout, а также код ее возврата;
    6. Если команда отсутствует в системе — бросается исключение.

    Как и в случае со smart-env, обеспечена поддержка Python 2 (правда, жертвенной крови потребовалось немного больше) и отсутствует поддержка Python 3.0-3.4.

    Планы по развитию библиотек

    Использовать библиотеки можно уже сейчас: обе выложены на официальный PyPI. Исходники доступны на Github (см. ниже).

    Обе библиотеки будут развиваться с учетом фидбека, собранного от заинтересовавшихся. И, если в smart-env, может, и сложно придумать разнообразие новых фич, то в python-shell точно есть еще что добавить:

    • поддержка неблокирующих вызовов;
    • возможность интерактивного общения с командой (работа с stdin);
    • добавление новых свойств (например, property для получения выхлопа из stderr);
    • реализация каталога доступных команд (для использования с функцией dir());
    • и т.д.

    Ссылки

    1. Библиотека smart-env: Github и PyPI
    2. Библиотека python-shell: Github и PyPI
    3. Телеграм-канал обновлений библиотек

    UPD 23.02.2020:
    * Репозитории перенесены, соответствующие ссылки обновлены
    * Версия python-shell==1.0.1 готовится к выходу 29.02.2020. Среди изменений — поддержка автокомплита команд и команды dir(Shell), запуск команд с Python-невалидным идентификатором, исправление багов.

    Источник

    Adblock
    detector