Установка и конфигурирование
В этом приложении представлены дополнительные сведения об установке и конфигурировании, предназначенные для тех, кому подобные темы в новинку. Они вынесены сюда потому, что далеко не всем читателям придется иметь дело с ними дело непосредственно. Однако из-за того, что здесь рассматриваются сопутствующие темы вроде переменных среды и аргументов командной строки, материал данного приложения заслуживает хотя бы беглого ознакомления.
Установка интерпретатора Python
Поскольку для запуска сценариев на Python необходим интерпретатор Python, первым шагом в использовании языка обычно является установка интерпретатора Python. Если он еще не доступен на вашем компьютере, то вам придется получить, установить и возможно сконфигурировать последнюю версию Python. Делать это нужно только один раз на каждом компьютере, а если вы будете запускать фиксированный двоичный файл (описанный в главе 2 первого тома) или самоустанавливающуюся систему, тогда шаги установки могут быть тривиальными или вообще отсутствовать.
Присутствует ли Python на компьютере?
Прежде чем делать что-либо еще, проверьте, имеется ли на компьютере последняя версия Python. Если вы работаете в среде Linux, Mac OS X или Unix, то интерпретатор Python вероятно уже установлен, хотя его версия может быть не самой новой. Ниже описаны необходимые действия.
• В Windows 7 и предшествующих версиях проверьте, существует ли группа Python в меню Все программы, доступном через кнопку Пуск. В Windows 8 и последующих версиях поищите Python в плитках на начальном экране, в интерфейсе АН apps (Все приложения) на экране Start (Пуск) или в проводнике файлов.
• В Mac OS X откройте окно терминала (Applications*^Utilities^Terminal (Приложе ния1^Служебные1^Терминал)) и введите python в командной строке. В данной системе интерпретатор Python, среда IDLE и комплект инструментов tkinter являются стандартными компонентами.
• В Linux и Unix введите python в приглашении командной оболочки (т.е. в окне терминала) и посмотрите, что произойдет. В качестве альтернативы попробуйте поискать “python” в обычных местах — /usr/bin, /usr/local/bin и т.д. Подобно Mac OS X в системах Linux интерпретатор Python является стандартным компонентом.
Если вы обнаружили интерпретатор Python, тогда удостоверьтесь в том, что он последней версии. Хотя в большей части книги подойдет любой из последних выпусков Python, основное внимание здесь сосредоточено на версиях Python 3.3 (3.7) и 2.7, поэтому имеет смысл установить именно указанные версии.
Говоря о версиях, рекомендуется начать с Python 3.3 или последующей версии, если вы изучаете Python с нуля и не нуждаетесь в работе с существующим кодом Python 2.Х; в противном случае вы должны применять Python 2.7. Тем не менее, ряд популярных систем, основанных на Python, по-прежнему используют старые выпуски (Python 2.6 и даже Python 2.5 все еще широко распространены), а потому если вы имеете дело с существующими системами, то выбирайте версию в соответствии со своими потребностями. В следующем разделе описаны места, где можно получить разнообразные версии Python.
Где взять интерпретатор Python
Если интерпретатор Python на вашем компьютере отсутствует, тогда вам придется установить его самостоятельно. Хорошая новость в том, что Python является системой с открытым кодом, которая свободно доступна в веб-сети и очень легко устанавливается на большинстве платформ.
Вы всегда можете получить самый последний выпуск стандартного Python на официальном веб-сайте Python по адресу http: //. Найдите на странице ссылку Downloads (Загрузки) и выберите выпуск для платформы, где вы будете работать. Вы обнаружите установщики для Windows и Mac OS X, полный исходный код (обычно требующий компиляции на компьютере с Linux, Unix или OS X для получения интерпретатора) и другие ресурсы.
Несмотря на то что в настоящее время Python является стандартным компонентом в Linux, вы можете также найти пакеты RPM для Linux в веб-сети (распаковывайте их с помощью утилиты rpm). На официальном веб-сайте Python также есть ссылки на страницы, где поддерживаются версии для других платформ, либо на самом веб-сайте python. org, либо за его пределами. Например, вы обнаружите сторонние установщики Python для Google Android, а также приложения для установки Python в среде Apple iOS.
Поиск с помощью Google — еще один великолепный способ найти пакеты установки Python. Среди других платформ вы заметите предварительно собранный интерпретатор Python для iPod, карманных устройств Palm, смартфонов Nokia, игровых консолей PlayStation и PSP, Solaris, AS/400 и Windows Mobile, хотя некоторые из них обычно отстают на несколько выпусков.
Если вы предпочитаете иметь среду Unix на компьютере с Windows, тогда вас может также заинтересовать установка средства Cygwin и его версии Python (http: / /www. cygwin. com). Cygwin — это подпадающие под действие лицензии GPL библиотека и инструментальный комплект, предоставляющие полную функциональность Unix на компьютерах Windows и включающие предварительно собранный интерпретатор Python, который задействует все инструменты Unix.
Вы также обнаружите Python на компакт-дисках с дистрибутивами Linux. Как правило, версии будут немного отставать от текущей, но обычно незначительно.
Кроме того, вы можете найти Python в рамках ряда бесплатных и коммерческих пакетов для разработки. Ниже перечислены некоторые альтернативные дистрибутивы.
ActiveState ActivePython
Пакет, который комбинирует Python с расширениями для научных расчетов, операционной системы Windows и других потребностей разработки, включая PyWin32 и IDE-среду Python Win.
Enthought Python Distribution
Комбинация Python с множеством дополнительных библиотек и инструментов, ориентированных на научные расчеты.
Portable Python
Смесь Python и добавочных пакетов, сконфигурированная для запуска непосредственно на портативном устройстве.
Pythonxy
Дистрибутив Python на основе Qt и Spyder, ориентированный на научные расчеты.
Conceptive Python SDK
Пакет, нацеленный на производственные, настольные и приложения для работы с базами данных.
PylMSL Studio
Коммерческий дистрибутив для численного анализа.
Anaconda Python
Дистрибутив для анализа и визуализации крупных наборов данных.
Приведенный перечень подвержен изменениям, поэтому ищите в веб-сети актуальную информацию по всем перечисленным и другим дистрибутивам. Одни дистрибутивы бесплатны, другие нет, а некоторые имеют как бесплатные, так и платные версии. Все они объединяют стандартный Python, бесплатно доступный на веб-сайте , с дополнительными инструментами, но способны упростить установку для многих пользователей.
Наконец, если вас интересуют альтернативные реализации Python, то поищите в веб-сети сведения о Jython (перенесенная версия Python для среды Java) и IronPython (Python для мира С#/.NET), которые были кратко описаны в главе 2 первого тома. Рассмотрение установки упомянутых систем выходит за рамки книги.
Шаги установки
После того, как вы загрузили интерпретатор Python, его понадобится установить. Шаги установки крайне специфичны к платформе, но ниже дается несколько подсказок для основных платформ, поддерживаемых Python (с перекосом в сторону Windows, т.к. вероятно именно здесь начинают знакомиться с Python большинство новоприбывших) .
Windows
Для Windows интерпретатор Python поставляется как самоусшанавливающийся файл MSI — просто дважды щелкните на его значке и щелкайте на кнопках Yes (Да) или Next (Далее) в открываемых впоследствии окнах, чтобы выполнить стандартную установку. Стандартная установка включает набор документации по Python, а также поддержку для tkinter (Tkinter в Python 2.Х), баз данных shelve и графического пользовательского интерфейса разработки IDLE. Версии Python 3.7 и 2.7 обычно устанавливаются в каталоги C:\Python37 и С: \Python27, хотя во время установки их можно изменить.
Ради удобства в Windows 7 и предшествующих версиях Python появляется в меню Все программы кнопки Пуск. Меню Python содержит пять элементов, которые обеспечивают быстрый доступ к распространенным задачам: запуск пользовательского интерфейса IDLE, чтение документации по модулям, запуск интерактивного сеанса, чтение стандартных руководств по Python и удаление. С большинством элементов связаны концепции, детально исследованные в других местах книги.
Во время установки в Windows интерпретатор Python также автоматически использует файловые ассоциации, чтобы зарегистрировать себя как программу, которая открывает файлы Python при щелчке на их значках (методика запуска программ была описана в главе 3 первого тома). В Windows можно также скомпилировать интерпретатор Python из его исходного кода, но обычно это не делается, и потому мы не будем рассматривать здесь все детали (см. python, org).
Есть еще одно замечание относительно установки в Windows. В следующем приложении приводится введение в запускающий модуль Windows, который поставляется, начиная с Python 3.3. Он изменяет ряд правил для установки, файловых ассоциаций и командных строк, но может служить ценным ресурсом, если вы имеете на своем компьютере несколько версий Python (скажем, Python 2.Х и Python З.Х). Согласно приложению Б установщик MSI для Python З.Х также предлагает возможность установки переменной среды PATH, чтобы включить каталог с установленным интерпретатором Python.
Linux
В среде Linux при отсутствии интерпретатора Python вы, скорее всего, можете получить его в форме одного или большего числа файлов RPM и распаковать их обычным образом. В зависимости от того, какие файлы RPM вы загрузили, один из них может быть предназначен для самого Python, а еще один — для добавления поддержки tkinter и среды IDLE. Поскольку операционная система Linux похожа на Unix, следующий абзац применим также и к ней.
Unix
Для систем Unix интерпретатор Python обычно компилируется из полного исходного кода на С. Как правило, это требует лишь распаковки файла и запуска команд configure и make; процедура построения интерпретатора Python конфигурируется автоматически в соответствии с системой, где он компилируется. Однако обязательно почитайте файл README, чтобы ознакомиться с дополнительными сведениями о процессе сборки. Так как интерпретатор Python относится к системам с открытым кодом, его исходный код можно свободно использовать и распространять.
На других платформах детали установки могут варьироваться в широких пределах, но в целом следуют нормальным соглашениям, принятым внутри платформы. Например, установка перенесенной версии Python для PalmOS под названием Pippy требует синхронизации с вашим карманным устройством, a Python для карманного устройства Sharp Zaurus, основанного на Linux, выглядел как один или несколько файлов . ip к, которые просто запускались с целью установки (вероятно, такие устройства все еще функционируют, но отыскать их в наши дни может быть нелегко).
Кроме того, интерпретатор Python можно устанавливать и применять на платформах Android и iOS, но методики установки и использования слишком специфичны к платформам, чтобы раскрывать их здесь. Описания дополнительных процедур установки и свежие новости о доступных перенесенных версиях ищите на веб-сайте Python.
Конфигурирование интерпретатора Python
После установки интерпретатора Python у вас может возникнуть желание сконфигурировать ряд системных настроек, которые оказывают влияние на то, каким образом интерпретатор Python запускает ваш код. (Если вы только приступили к изучению языка, тогда можете пропустить весь текущий раздел; для базовых программ обычно нет необходимости устанавливать какие-либо системные настройки.)
В общем случае линии поведения интерпретатора Python можно конфигурировать с помощью настройки переменных среды и параметров командной строки. В настоящем разделе мы кратко обсудим оба варианта, но обязательно ознакомьтесь с дополнительными сведениями по представленным здесь темам, обратившись в документацию.
Переменные среды Python
Переменные среды, также известные как переменные командной оболочки или переменные DOS, являются настройками уровня системы, которые находятся вне интерпретатора Python и потому могут применяться для настройки поведения интерпретатора каждый раз, когда он запускается на отдельно взятом компьютере. Интерпретатор Python распознает несколько переменных среды, но лишь некоторые из них используются достаточно часто, чтобы заслуживать подробного объяснения. В табл. А.1 приведена сводка по основным переменным среды, касающимся Python (информацию об остальных ищите на справочных ресурсах Python).
| Таблица А.1. Важные переменные среды |
|---|
| |
| Переменная | Роль |
| PATH (или path) | Путь поиска командной оболочки системы (для нахождения python) |
| PYTHONPATH | Путь поиска модулей Python (для операций импортирования) |
| PYTHONSTARTUP | Путь к файлу запуска для интерактивной оболочки Python |
| TCL LIBRARY, | Переменные для расширения tkinter |
| TK_LIBRARY | |
| PY PYTHON, | Стандартные настройки для запускающего модуля Windows |
| PY PYTH0N3, | (см.приложение Б) |
| PY PYTH0N2 | |
Хотя использовать перечисленные переменные легко, ниже дается ряд подсказок.
PATH
Настройка PATH содержит список каталогов, в которых операционная система ищет исполняемые программы, когда они запускаются без указания полного пути к каталогу. Обычно она должна включать каталог, где находится интерпретатор Python (программа python в Unix, файл python. ехе в Windows).
Вам вообще не нужно устанавливать эту переменную, если вы собираетесь работать в каталоге, в котором расположен интерпретатор Python, или вводить полный путь к Python в командной строке. Скажем, в Windows переменная ере* ды PATH не играет никакой роли, если перед запуском любого кода вы вводите команду cd С: \Python37 (чтобы перейти в каталог, где находится Python — хотя, как объяснялось в главе 3 первого тома, хранить там собственный код не рекомендуется) или всегда набираете С: \Python37\python (с полным путем) вместо просто python.
Также обратите внимание, что настройка PATH предназначена главным образом для запуска программ из командной строки; она не имеет какого-либо значения при запуске через щелчки на значках и IDE-среду — в первом случае применяются файловые ассоциации, а во втором используются встроенные механизмы, поэтому такой шаг конфигурирования не требуется. В приложении Б описан вариант автоматической настройки PATH во время установки.
PYTHONPATH
Роль настройки PYTHONPATH похожа на роль PATH: интерпретатор Python обращается к переменной PYTHONPATH при определении местонахождения файлов модулей, когда вы импортируете их в программе. В переменной PYTHONPATH указывается зависимый от платформы список имен каталогов, разделяемых двоеточиями в Unix и точками с запятой в Windows. Список обычно включает только каталоги с вашим исходным кодом. Содержимое PYTHONPATH объединяется в путь поиска импортируемых модулей sys .path вместе с контейнерным каталогом сценария, любыми настройками файлов путей .pth и каталогами стандартных библиотек.
Вам не понадобится устанавливать переменную PYTHONPATH, если вы не планируете выполнять импортирование между каталогами. Поскольку интерпретатор Python всегда автоматически производит поиск файла верхнего уровня в домашнем каталоге программы, данная настройка требуется, только если модулю необходимо импортировать еще один модуль, который находится в другом каталоге. Ознакомьтесь также с обсуждением файлов путей . pth позже в текущем приложении для создания альтернативы PYTHONPATH. Дополнительные сведения о пути поиска модулей ищите в главе 22 первого тома.
PYTHONSTARTUP
В случае установки переменной среды PYTHONSTARTUP в путь к файлу с кодом на Python интерпретатор Python автоматически выполняет код из файла всякий раз, когда вы запускаете интерактивный сеанс, как если бы он вводится в командной строке интерактивного сеанса. Переменная PYTHONSTARTUP применяется редко, но является удобным способом гарантировать, что вы всегда загружаете определенные утилиты при работе в интерактивном сеансе; она сохраняет импортирование каждый раз, когда вы запускаете сеанс Python.
Настройки tkinter
Если вы хотите использовать инструментальный комплект для построения графических пользовательских интерфейсов под названием tkinter (Tkinter в Python 2.Х), то можете указать в переменных TCL LIBRARY и TK LIBRARY имена каталогов библиотек систем Тс1 и Тк (почти как PYTHONPATH). Тем не менее, в системах Windows подобные настройки не обязательны (поддержка tkinter устанавливается параллельно с Python), а также обычно не требуются в системах Mac OS X и Linux, если только базовые библиотеки Тс1 и Тк не стали недействительными или не находятся в нестандартных каталогах (дополнительные детали ищите на странице Download веб-сайта python.org).
PY_PYTHON, PYJPYTH0N3, PY_PYTH0N2
Настройки PY_PYTHON, PY_PYTH0N3 и PY_PYTH0N2 применяются для указания стандартных версий Python, когда вы используете запускающий модуль Windows, который поставляется, начиная с версии Python 3.3. Запускающий модуль Windows подробно рассматривается в приложении Б.
Так как описанные выше переменные среды являются внешними по отношению к самому интерпретатору Python, момент их модификации неважен: изменения можно вносить до или после установки Python, но перед действительным запуском интерпретатора Python — чтобы изменения вступили в силу, обязательно перезапустите IDE-среду и интерактивный сеанс Python.
tkinter и IDLE в Linux и Mac OS
Среда IDLE, описанная в главе 3 первого тома, представляет собой программу на Python с графическим пользовательским интерфейсом tkinter. Модуль tkinter (Tkinter в Python 2.Х) — это инструментальный комплект для построения графических пользовательских интерфейсов, который автоматически устанавливается вместе со стандартным Python в Windows и является неотъемлемой частью систем Mac OS X и Linux.
Однако в некоторых системах Linux внутренняя библиотека для построения графических пользовательских интерфейсов может не быть стандартным устанавливаемым компонентом. Чтобы при необходимости добавить такую поддержку к Python в Linux, попробуйте ввести командную строку вида yum install tkinter для автоматической установки библиотек, лежащих в основе tkinter. Прием должен работать в дистрибутивах Linux (и ряде других систем), где доступна программа установки yum; в противном случае ищите сведения в документации по установке для имеющейся платформы.
Как также обсуждалось в главе 3 первого тома, среда IDLE в Mac OS X вероятно находится в папке MacPython (или Python N.M) внутри папки Applications (наряду с PythonLauncher, используемым для запуска программ с помощью щелчков в Finder), но обязательно просмотрите страницу Downloads на веб-сайте python.org, если со средой IDLE возникают трудности; в некоторых версиях Mac OS X может потребоваться установить обновление.
Способы установки конфигурационных параметров
Способ установки переменных среды, относящихся к Python, и то, во что их устанавливать, зависит от типа компьютера, на котором вы работаете. И снова помните
о том, что вы не обязаны устанавливать их немедленно; в случае, если вы работаете в IDLE (см. главу 3 первого тома) и храните все свои файлы в том же самом каталоге, заблаговременное конфигурирование вероятно не потребуется.
Но предположим, например, что у вас есть в целом полезные файлы модулей в каталогах utilities и packagel где-то на компьютере, и вы хотите иметь возможность импортировать указанные модули в файлах, расположенных в других каталогах. То есть для загрузки файла по имени spam.py из каталога utilities или packagel вы желаете указывать в другом файле оператор следующего вида:
import spam
Чтобы заставить это работать, вам тем или иным образом придется сконфигурировать путь поиска модулей для включения каталога, содержащего spam.py. Ниже приводится несколько советов относительно такого процесса с применением PYTHONPATH в качестве примера; при необходимости проделайте то же самое с другими настройками вроде PATH (начиная с Python 3.3, переменная среды PATH может устанавливаться автоматически: см. приложение Б).
Переменные командной оболочки Unix/Linux
В системах Unix способ установки переменных среды зависит от используемой командной оболочки. В командной оболочке csh вы можете добавить в файл .cshrc или . login показанную ниже строку, чтобы установить путь поиска модулей Python:
setenv PYTHONPATH /usr/home/pycode/utilities:/usr/lib/pycode/packagel
Это сообщает интерпретатору Python о том, что импортируемые модули нужно искать в двух пользовательских каталогах. Если же вы применяете командную оболочку ksh, тогда установка будет располагаться в файле . kshrc и выглядеть следующим образом:
export PYTHONPATH="/usr/home/pycode/utilities:/usr/lib/pycode/packagel"
В других командных оболочках может использоваться отличающийся (но аналогичный) синтаксис.
Переменные DOS (и более старые версии Windows)
Если вы работаете в MS-DOS или какой-то теперь уже довольно старой версии Windows, то вам понадобится добавить команду конфигурирования переменной среды в файл С: \autoexec.bat и перезагрузить систему, чтобы изменения вступили в силу. Команда конфигурирования на таких компьютерах имеет синтаксис, уникальный для DOS:
set PYTHONPATH=c:\pycode\utilities;d:\pycode\packagel
Вы можете ввести такую команду также в окне консоли DOS, но тогда настройка будет активной лишь для этого одного окна консоли. Помещение изменения в файл .bat делает его постоянным и глобальным для всех программ, хотя в последние годы такая методика была замещена так, как описано в следующем разделе.
Графический пользовательский интерфейс для установки переменных среды Windows
Во всех последних версиях Windows вы можете устанавливать PYTHONPATH и другие переменные через графический пользовательский интерфейс для установки переменных среды, не занимаясь редактированием файлов, вводом командных строк и перезагрузкой системы. Откройте панель управления, выберите элемент Система, щелкните на вкладке или ссылке Дополнительные параметры системы и затем на кнопке Переменные среды, чтобы редактировать или добавлять новые переменные (PYTHONPATH обычно будет новой пользовательской переменной). Применяйте такое же имя и значение переменной, как в команде set в предыдущем разделе.
Перезагрузка системы не требуется, но обязательно перезапустите интерпретатор Python, если он функционировал, чтобы изменения вступили в силу — путь поиска импортируемых модулей настраивается только во время начального запуска. В случае работы в окне командной строки Windows также возможно понадобится его перезапуск для подхвата изменений.
Реестр Windows
Если вы являетесь опытным пользователем Windows, то можете также сконфигурировать путь поиска модулей, используя редактор реестра Windows. Чтобы открыть редактор реестра, введите regedit в окне, появляющемся в результате выбора пункта меню Пуск1^ Выполнить..., в поле поиска ниже кнопки Пуск или в окне командной строки. При условии, что редактор реестра доступен в вашей системе, вы можете перейти к записям Python и внести желаемые изменения. Тем не менее, процедура довольно тонкая и подвержена ошибкам, так что если вы не очень хорошо знакомы с реестром, тогда рекомендуется избрать другие варианты (на самом деле это похоже на хирургию головного мозга для вашего компьютера, а потому будьте предельно осторожны!).
Файлы путей
Наконец, если вы предпочитаете расширять путь поиска модулей с помощью файла путей .pth, а не переменной PYTHONPATH, то можете создать текстовый файл (скажем, С: \Python37\mypath.pth), содержимое которого в Windows выглядит следующим образом:
с:\pycode\utilities
d:\pycode\packagel
Его содержимое будет варьироваться в зависимости от платформы, а контейнерный каталог может отличаться для разных платформ и выпусков Python. Интерпретатор Python автоматически находит данный файл во время своего начального запуска.
Имена каталогов в файлах путей могут быть абсолютными или относительными к каталогу, где эти файлы хранятся; допускается применять множество файлов .pth (добавятся все указанные в них каталоги), и файлы .pth могут присутствовать в разнообразных автоматически проверяемых каталогах, которые являются специфичными к платформе и версии. В целом выпуск Python, пронумерованный как Python N.M, обычно ищет файлы путей внутри каталогов С: \PythonNM и С: \PythonNM\Lib\site-packages в Windows и внутри каталогов /usr/local/lib/pythonN.M/site-packages и /usr/local/lib/site-python в Unix/Linux. Использование файлов путей для конфигурирования пути поиска импортируемых модулей sys .path более подробно описано в главе 22 первого тома.
Поскольку настройки среды часто необязательны, а книга не посвящена командным оболочкам операционных систем, за дополнительными деталями обращайтесь к другим источникам. Просмотрите страницы руководства по своей командной оболочке или другую документацию, а при возникновении трудностей с выяснением, как должны выглядеть ваши настройки, проконсультируйтесь с системным администратором или другим местным экспертом.
Аргументы командной строки интерпретатора Python
При запуске интерпретатора Python из командной строки системы (т.е. приглашения командной оболочки или окна командной строки) вы можете передавать разнообразные аргументы для управления тем, как он будет выполнять ваш код. В отличие от переменных среды уровня системы, которые были описаны в предыдущем разделе, аргументы командной строки могут быть разными каждый раз, когда вы запускаете свой сценарий. Полная форма командной строки для вызова интерпретатора Python 3.7 выглядит примерно так (в Python 2.7 она почти такая же, но с небольшими отличиями):
python [-bBdEhilOqsSuvVWxX] [-с команда | -ш имя-модуля \ сценарий | - ] [аргументы]
Ниже будут кратко представлены наиболее часто применяемые аргументы интерпретатора Python. Дополнительные детали о доступных аргументах командной строки, которые здесь не раскрываются, ищите в руководствах или справочниках по Python. А еще лучше запросите у самого интерпретатора Python с помощью такой команды:
C:\code> python -h
Интерпретатор Python отобразит справочный текст с описанием всех доступных аргументов командной строки. Если вы имеете дело со сложными командными строками, тогда обязательно ознакомьтесь со стандартными библиотечными модулями в данной области: первоначальным getop, более новым argparse и теперь устаревшим (начиная с Python 3.2) optparse, которые поддерживают развитую обработку командных строк. Также просмотрите руководства и справочники по стандартной библиотеке Python, чтобы узнать больше о задействованных далее модулях pdb и profile.
Запуск файлов сценариев с аргументами
В большинстве случаев из формата командной строки Python используются только части сценарий и аргументы для запуска файла с исходным кодом программы и передачи аргументов, потребляемых самой программой. В целях иллюстрации рассмотрим показанный ниже сценарий, находящийся в текстовом файле по имени showargs .ру внутри С: \code или другого каталога по вашему выбору. Он выводит аргументы командной строки, доступные сценарию как sys . argv, который представляет собой список Python строк Python (способы создания и запуска файлов сценариев Python обсуждались в главах 2 и 3 первого тома; здесь нас интересуют лишь аргументы командной строки):
# Файл showargs .ру
import sys
print(sys.argv)
В следующей команде части python и showargs .ру могут также включать полные пути к каталогам — первая полагается на переменную среды PATH, а вторая на то, что файл сценария находится в текущем каталоге. Три аргумента (а b -с), предназначенные для сценария, обнаруживаются в списке sys. argv и могут там инспектироваться кодом сценария; первым элементом в sys. argv всегда будет имя файла сценария, когда оно известно:
C:\code> python showargs.ру а b -с # Самая распространенная команда:
# запуск файла сценария
[1showargs.ру' , 'а*, 'Ь', '-с']
Как объяснялось в разных местах книги, списки Python выводятся в квадратных скобках, а строки отображаются в кавычках.
Запуск кода, предоставляемого в аргументах и стандартном входном потоке
Другие варианты спецификации формата кода позволяют предоставлять интерпретатору Python код, подлежащий запуску, в самой командной строке (-с) и принимать код из стандартного входного потока (символ — означает чтение из канала или входного потока, перенаправленного в файл):
C:\code> python -с "print(2 ** 100)” # Читать код из аргумента
# командной строки
1267 65060022822 94 014 967 0320537 6
C:\code> python -с "import showargs" # Импортировать файл для запуска его кода ['-с']
C:\code> python - < showargs.ру а b -с # Читать код из стандартного
# входного потока
'а', 'Ь', '-с']
C:\code> python - ab -с< showargs.ру # Тот же результат, что и в
# предыдущей команде
’ а' , 'Ь', '-с']
Запуск модулей в пути поиска
Спецификация кода -ш обеспечивает нахождение модуля в пути поиска модулей
Python и его запуск в качестве сценария верхнего уровня (как модуля_main ). То
есть интерпретатор Python ищет сценарий тем же самым способом, что и операции импортирования, с применением списка каталогов, обычно известного как sys .path, который включает текущий каталог, настройки PYTHONPATH и стандартные библиотеки. Расширение .ру здесь не указано, потому что имя файла трактуется как модуль.
C:\code> python -m showargs a b -с # Отыскать /за пустить модуль как сценарий [' с: WcodeWshowargs. ру', 'а', 'Ь', '-с']
Аргумент -т также поддерживает запуск инструментов, модулей в пакетах с относительным импортированием и без него и модулей, находящихся в архивах . zip. Скажем, -ш часто используется для запуска модулей отладчика pdb и профилировщика profile из командной строки, чтобы инициировать работу сценария вместо его выполнения в интерактивном режиме:
C:\code> python # Интерактивный сеанс отладчика
»> import pdb
>>> pdb.run(* import showargs')
. . .остальное не показано: см. документацию по pdb. . .
C:\code> python -m pdb showargs.py a b -с # Отладка сценария (с=продолжить)
> С:\code\showargs.ру(2)<module>()
-> import sys (Pdb) с
['showargs.py', 'a', ' b', 1 —с']
...остальное не показано: q для выхода...
Профилировщик запускает и измеряет время выполнения вашего кода; его вывод может варьироваться в зависимости от выпуска Python, операционной системы и компьютера:
C:\code> python -m profile showargs.py a b -с # Профилирование сценария [1showargs.py1, 'a', 'b', '-c']
9 function calls in 0.016 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
2 0.000 0.000 0.000 0.000 :0(charmap_encode)
1 0.000 0.000 0.000 0.000 :0(exec)
. . .остальное не показано: см. документацию по profile. . .
Вы также можете применять аргумент -ш, чтобы породить процесс для программы с графическим пользовательским интерфейсом IDLE (см. главу 3 первого тома), находящейся в стандартной библиотеке, из другого каталога. Кроме того, посредством аргумента -т вы можете запускать модули инструментов pydoc и timeit с командными строками, как делалось в главах 15 и 21 первого тома:
c:\code> python -m idlelib.idle -n # Запустить IDLE в пакете, без подпроцессов
c:\code> python -m pydoc -b # Запустить модули инструментов pydoc и timeit
c:\code> python -m timeit -n 1000 -r 3 -s "L = [1,2,3,4,5]" "M = [x + 1 for x in L]"
Оптимизированный и небуферизированный режимы
Непосредственно после слова python и перед указанием кода, подлежащего выполнению, интерпретатор Python принимает дополнительные аргументы, которые управляют его собственным поведением. Эти аргументы потребляются самим интерпретатором Python и не предназначены для выполняемого сценария. Например, -О запускает Python в оптимизированном режиме, а -и вынуждает стандартные потоки быть небуферизированными — в последнем случае любой выводимый текст будет немедленно финализирован, не задерживаясь в буфере:
C:\code> python -О showargs.ру а b -с # Оптимизированный режим: построить/
# запустить байт-код .руо
C:\code> python -u showargs.ру a b -с # Небуферизированный стандартный
# выходной поток
Интерактивный режим после выполнения
В заключение флаг -i обеспечивает вход в интерактивный режим после выполнения сценария, что особенно полезно в качестве инструмента отладки, поскольку вы можете выводить финальные значения переменных после успешного запуска для получения дополнительных деталей:
C:\code> python -i showargs.ру a b -с # Перейти в интерактивный режим после
# завершения сценария
['showargs.ру', 'а', ’Ь1, '-с']
>>> sys # Финальное значение sys: импортированный модуль
<module 'sys' (built-in)>
>>> AZ
Вдобавок вы можете выводить таким способом переменные после того, как исключение привело к прекращению работы сценария, чтобы посмотреть, каким образом они выглядели, когда произошло исключение, даже если сценарий не был запущен в режиме отладки — хотя здесь также можно запустить инструмент анализа отладчика (type является командой отображения содержимого файлов в Windows; в других системах попробуйте cat или что-нибудь еще):
С:\code> type divbad.ру
X = о
print(1 / X)
C:\code> python divbad.py # Запустить сценарий, содержащей ошибку
...текст сообщения об ошибке не показан...
ZeroDivisionError: division by zero Ошибка деления на ноль: деление на ноль
C:\code> python -i divbad.ру # Вывести значения переменных после
# возникновения ошибки ...текст сообщения об ошибке не показан...
ZeroDivisionError: division by zero Ошибка деления на ноль: деление на ноль
»> X
О
»> import pdb # Теперь запустить полный сеанс отладки
»> pdb.pm()
> С:\code\divbad.py(2)<module>()
-> print(1 / X)
(Pdb) quit
Аргументы командной строки Python 2.Х
Помимо упомянутых выше интерпретатор Python 2.7 поддерживает аргументы, которые содействуют совместимости с Python З.Х (-3 для выдачи предупреждений о несовместимостях и -Q для управления моделями операции деления) и обнаруживают несогласованное использование отступов посредством табуляции, что всегда делается в Python З.Х (-t; см. главу 12). При необходимости вы всегда можете запросить информацию о доступных аргументах у самого интерпретатора Python 2.Х:
С:\code> с:\python27\python -h
Командные строки запускающего модуля, появившегося в Python 3.3
Формально в предыдущем разделе были описаны аргументы, которые вы можете передавать самому интерпретатору Python — программе, обычно называющейся python.exe в Windows и python в Linux (в Windows расширение .ехе, как правило, опускается). В приложении Б вы увидите, что запускающий модуль, появившийся в Python 3.3, дополняет эту историю для пользователей Python 3.3 и последующих версий или автономного пакета запуска. Он добавляет новые исполняемые файлы, которые принимают номера версий как аргументы в командных строках, применяемых для запуска интерпретатора Python и ваших сценариев (файл what. ру будет представлен в приложении Б; он просто выводит номер версии Python):
C:\code> ру what.py # Командные строки запускающего модуля Windows
3.7.3
C:\code> ру -2 what.py # Переключатель номера версии
2.7.3
C:\code> ру -3.3 -i what.py -а -b -с # Аргументы для ру, python и сценария
3.3.0
>» AZ
Фактически, как показывает последний запуск в предыдущем примере, командные строки, использующие запускающий модуль, могут предоставлять аргументы для самого запускающего модуля (-3.3), интерпретатора Python (-i) и вашего сценария (-а, -Ь и -с). Запускающий модуль также способен разбирать номера версий из строк
# ! в стиле Unix, находящихся в начале файлов сценариев, что будет обсуждаться в следующем приложении.
Дополнительная помощь
В наши дни стандартный набор руководств включает ценные подсказки по применению интерпретатора Python на различных платформах. Стандартный набор руководств становится доступным после установки Python через меню Пуск (например, элемент Python 3.7 Manuals в группе Python 3.7), а также в онлайновом режиме на веб-сайте http: //. Поищите в наборе руководств раздел верхнего уровня, озаглавленный “Using the Python Interpreter” (“Использование интерпретатора Python”), в котором предлагаются дополнительные подсказки и советы, а также детали о межплатформенных переменных среды и командных строках.
Как обычно, веб-сеть тоже является вашим союзником, особенно в области, часто развивающейся быстрее, чем могут обновляться книги вроде этой. Учитывая широкое распространение Python, высока вероятность того, что вы сумеете найти в веб-сети ответы на все вопросы по высокоуровневому применению.
Приложение
Запускающий модуль Windows для Python
В этом приложении описан запускающий модуль Windows для Python, который автоматически устанавливается, начиная с версии Python 3.3, и доступен отдельно в веб-сети для использования с более старыми версиями. Он предоставляет дополнительный уровень кода, который выбирает и запускает установленный интерпретатор Python, обеспечивая согласованное выполнение программ, когда на одном компьютере сосуществует несколько версий Python.
Настоящее приложение рассчитано на программистов, работающих с Python в Windows. Несмотря на специфичную для платформы природу, его целевой аудиторией являются как новички в Python (большинство из них начинает именно в Windows), так и опытные разработчики на Python, которые пишут код, переносимый между Windows и Unix. Вы увидите, что данный запускающий модуль достаточно радикально изменяет правила в Windows, чтобы оказать влияние на всех, кто применяет Python в Windows или собирается заняться этим в будущем.
Наследие Unix
Чтобы полностью понять протоколы запускающего модуля, мы должны начать с краткого урока истории. Разработчики Unix давно продумали протокол для назначения программы, которая будет запускать код сценария. В системах Unix (включая Linux и Mac OS X) первая строка в текстовом файле сценария является особой, если она начинается с двухсимвольной последовательности: # !.
В главе 3 первого тома приводился краткий обзор данной темы, но здесь предлагается иной взгляд. В сценариях Unix такие строки задают программу, которая должна выполнить остальное содержимое сценария, указывая ее после # !.
Программа указывается с использованием либо полного пути к каталогу, где она находится, либо вызова Unix-утилиты env, которая ищет целевую программу в соответствии с PATH — настраиваемой переменной среды со списком каталогов для поиска в них исполняемых программ:
#!/usr/local/bin/python
. . . код сценария. . . # Запустить под управлением этой конкретной программы
#!/usr/bin/env python
. . .код сценария. . . # Запустить под управлением программы python, найденной в PATH
Делая такой сценарий исполняемым (например, через chmod +х script .ру), вы можете запускать его за счет ввода только имени файла сценария в командной строке; последовательность # ! в начале файла затем направляет командную оболочку Unix на программу, которая выполнит остаток кода в файле. В зависимости от структуры установки платформы указанное после символов # ! имя python может быть действительной исполняемой программой или символической ссылкой на исполняемую программу, расположенную где-то в другом месте. В строках подобного рода можно также явно указывать более конкретную исполняемую программу, такую как python3. В любом случае за счет изменения строк # !, символических ссылок либо настроек PATH у разработчиков в Unix есть возможность направлять сценарий подходящей установленной версии интерпретатора Python.
Конечно, ничего из описанного выше не относится к среде Windows, в которой строки #! не имеют какого-то особого смысла. Исторически сложилось так, что в Windows сам интерпретатор Python игнорировал такие строки, считая их комментариями (символ # начинает комментарий в языке). И все же идея выбора исполняемой программы интерпретатора Python для каждого файла представляет собой захватывающую возможность в мире, где версии Python 2.Х и Python З.Х часто сосуществуют на одном компьютере. Учитывая тот факт, что в любом случае многие программисты предусматривают строки # ! для переносимости в Unix, похоже, идея созрела для эмуляции.
Наследие Windows
В другом лагере модель установки очень сильно отличалась. В прошлом (точнее, до версии Python 3.3) установщик Windows обновлял глобальный реестр Windows так, что последняя версия интерпретатора Python, установленная на компьютере, и была той версией, которая открывала файлы Python, когда совершался двойной щелчок на их значках или запуск в командной строке по прямым именам.
Некоторые пользователи Windows могут опознать это как файловые ассоциации, конфигурируемые в окне Программы по умолчанию панели управления. В Windows нет необходимости делать файлы исполняемыми, как требуется для сценариев Unix. Фактически концепция подобного рода в Windows отсутствует — файловых ассоциаций и команд достаточно для того, чтобы запускать файлы в качестве программ.
В рамках такой модели установки, если вы хотите открыть файл с помощью версии, отличающейся от последней установленной, то должны предоставить в командной строке полный путь к нужному интерпретатору Python или вручную обновить файловые ассоциации для запуска желаемой версии. Можно было бы также направлять обобщенные команды python на конкретный интерпретатор Python, устанавливая либо изменяя настройку PATH, но это придется делать самостоятельно, вдобавок прием неприменим для запуска сценариев двойным щелчком на значках или в других контекстах.
Именно так выглядит естественный порядок в Windows (когда производится двойной щелчок на файле .doc, то обычно открывается последняя установленная версия редактора Word), и подобное положение вещей существовало с тех пор, как появился Python для Windows. Однако прием не настолько идеален при наличии сценариев Python, требующих разных версий на одном и том же компьютере — ситуация, которая становится все более распространенной и, пожалуй, даже обычной в эру двух линеек Python 2.X/Python З.Х. Запуск нескольких версий Python в среде Windows до выхода Python 3.3 был утомительным для разработчиков и обескураживающим для новоприбывших.
Введение в запускающий модуль Windows
Запускающий модуль Windows, который поставляется и автоматически устанавливается, начиная с версии Python 3.3, а также доступен в виде автономного пакета для использования с более ранними версиями, устраняет описанные выше недочеты предшествующей модели установки за счет предоставления двух новых исполняемых файлов:
• ру. ехе для консольных программ;
• pyw. ехе для программ, отличающихся от консольных (обычно имеющих графический пользовательский интерфейс).
Указанные две исполняемые программы регистрируются для открытия соответственно файлов .ру и .pyw через файловые ассоциации Windows. Подобно первоначальной основной программе python. ехе (роль которой они не умаляют, но могут в значительной степени заместить ее) новые исполняемые программы также зарегистрированы для открытия файлов байт-кода, запускаемых напрямую. В рамках своих возможностей новые исполняемые программы:
• автоматически открывают файлы исходного кода и байт-кода Python, которые запускаются двойным щелчком на значках или вводом команд с именами файлов, через файловые ассоциации Windows;
• обычно устанавливаются в пути поиска системы и в случае применения в командной строке не требуют указания пути к каталогу или настройки переменной среды PATH;
• позволяют легко передавать номера версий Python как аргументы командной строки при запуске сценариев и интерактивных сеансов;
• разбирают строки комментариев # ! в стиле Unix, находящиеся в начале сценариев, чтобы определить, какая версия интерпретатора Python должна использоваться для запуска кода внутри файла.
Совокупный эффект заключается в том, что при наличии нескольких версий Python в среде Windows благодаря запускающему модулю вы больше не ограничены версией, установленной последней, либо полными командными строками. Взамен вы можете выбирать версии явно на основе файлов и команд, а также указывать версии в частичной или полной форме в обоих контекстах. Ниже описано, как все работает.
1. Чтобы выбирать версии для каждого файла, помещайте в начало сценариев комментарии в стиле Unix следующего вида:
#!python2
#!/usr/bin/python2.7 #!/usr/bin/env python3
2. Чтобы выбирать версии для каждой команды, применяйте командные строки в следующих формах:
• ру -2 т.ру
• ру -2 . 7 т.ру
• ру -3 т.ру
Например, первая из указанных методик может служить своего рода директивой для объявления версии Python, на которую полагается сценарий, и которая будет применяться запускающим модулем всякий раз, когда сценарий запускается командной строкой или двойным щелчком на значке (ниже приведены вариации файла по имени script .ру):
. Сценарий Python З.Х. . . # Выполняется под управлением последней
# установленной версии Python З.Х
python2
.Сценарий Python 2.Х. . . # Выполняется под управлением последней
# установленной версии Python 2.Х
python2.6
.Сценарий Python 2.6... # Выполняется под управлением
# версии Python 2.6 (только)
В среде Windows команды вводятся в окне командной строки с подсказкой, обозначаемой здесь с помощью С: \code>. Первая команда ниже дает такой же результат, как вторая и двойной щелчок на значке, из-за файловых ассоциаций:
C:\code> script.ру # Выполняется в соответствии со строкой #/ файла,
# если она есть, иначе так, как принято по умолчанию C:\code> ру script.ру # То же самое, но ру.ехе запускается явно
В качестве альтернативы вторая методика из описанных выше позволяет выбирать версии с помощью аргументов командной строки:
С: \code> ру -3 script.ру # Выполняется под управлением последней версии Python З.Х C:\code> ру -2 script.py # Выполняется под управлением последней версии Python 2.Х C:\code> ру -2.6 script.py # Выполняется под управлением версии Python 2. б (только)
Прием работает при запуске как сценариев, так и интерактивного сеанса интерпретатора (когда сценарий не указан):
C:\code> ру -3 # Запускает последнюю версию Python З.Х,
# интерактивный сеанс
C:\code> ру -2 # Запускает последнюю версию Python 2.Х,
# интерактивный сеанс
C:\code> ру -3.1 # Запускает версию Python 3.1 (только) ,
# интерактивный сеанс
C:\code> ру # Запускает версию Python, принятую по умолчанию
При наличии строки # ! в файле и аргумента с номером версии в командной строке версия, заданная в командной строке, аннулирует версию, указанную в директиве
# ! файла:
#! python3.2
...Сценарий Python З.Х...
C\code> ру script.py # Выполняется под управлением версии Python 3.2
# в соответствии с директивой файла
C\code> ру -3.1 script.py # Выполняется под управлением версии Python 3.1,
# даже если присутствует Python 3.2
Запускающий модуль также использует эвристические правила для выбора конкретной версии Python, когда она опущена или описана лишь частично. Скажем, в случае указания только 2 запускается последняя версия Python 2.Х, а если версия опущена, то предпочтение отдается Python З.Х.
Явный выбор версии выглядит полезным дополнением для Windows, где многие (вероятно даже большинство) новоприбывших получают свое первое представление о языке, особенно в текущем двойственном мире Python 2.X/Python З.Х. Он делает возможным более элегантное сосуществование файлов Python 2.Х и Python З.Х на одном компьютере и предлагает разумный подход к управлению версиями в командной строке.
Исчерпывающие сведения о запускающем модуле Windows, включая более продвинутые средства и сценарии использования, описание которых здесь либо сокращено, либо вообще опущено, ищите в пояснительной записке по выпуску Python и в документах РЕР. Среди прочего запускающий модуль также позволяет выбирать между 32-и 64-разрядными установленными версиями, указывать принятые по умолчанию версии в конфигурационных файлах и определять специальное расширение командных строк # !.
Учебное руководство по запускающему модулю Windows
Читателям, знакомым с написанием сценариев в Unix, предыдущего раздела может оказаться достаточно, чтобы приступить к работе. Для других в настоящем разделе предоставляется дополнительный контекст в форме учебного руководства, демонстрирующего конкретные примеры запускающего модуля в действии, которые вы можете отследить. Тем не менее, попутно здесь также раскрываются дальнейшие детали о запускающем модуле, поэтому даже опытные пользователи Unix могут извлечь пользу от беглого просмотра раздела.
Для начала мы будем применять показанный далее простой сценарий what .ру, который может запускаться под управлением Python 2.Х и З.Х и выдает номер версии интерпретатора Python, выполняющего его код. В нем используется sys.version — строка, первый компонент которой после разделения по пробельным символам содержит номер версии Python:
#!python3
import sys
print(sys.version.split () [0]) # Первая часть строки
Наберите код данного сценария в предпочитаемом редакторе текстовых файлов, откройте окно командной строки и перейдите в каталог, где сохранили сценарий (вместо С: \code можно выбрать любой другой каталог по собственному усмотрению; подсказки по работе в Windows приводились в главе 3 первого тома).
Комментарий в первой строке сценария служит указанием требующейся версии Python; по соглашениям, принятым в Unix, он должен начинаться с #! и допускает наличие пробела перед python3. На компьютере установлены версии Python 2.7, 3,1, 3.2, 3.3 и 3.7; давайте посмотрим, какая версия запускается в случае модификации первой строки сценария в последующих разделах, и в ходе дела исследуем директивы файлов, командные строки и принятые стандарты.
Шаг 1: использование директив версий в файлах
В том виде, как сценарий реализован, при запуске двойным щелчком на значке или посредством командной строки первая строка предписывает зарегистрированному запускающему модулю ру. ехе выполнить его с применением последней установленной версии Python З.Х:
# ! python3
import sys
print(sys.version.split () [0])
C:\code> what.py # Выполняется в соответствии с директивой файла
3.7.3
C:\code> ру what.py # То же самое: последняя версия Python З.Х
3.7.3
Опять-таки пробел после # ! необязателен; здесь он добавлен, чтобы удостовериться в этом. Обратите внимание, что первая команда запуска what.py эквивалентна двойному щелчку на значке и полному варианту ру what .ру, т.к. программа ру. ехе зарегистрирована для автоматического открытия файлов .ру в файловых ассоциациях реестра Windows при установке запускающего модуля.
Также имейте в виду, что когда в документации по запускающему модулю (включая данное приложение) упоминается последняя версия, то под ней понимается версия с наибольшим номером. То есть речь идет о последней выпущенной версии, а не о версии, которая была установлена на компьютере позже всех (например, если вы установили Python 3.3 после Python 3.7, то # ! python3 выберет Python 3.7). Запускающий модуль циклически проходит по имеющимся на компьютере версиям интерпретаторов Python, чтобы отыскать версию с наибольшим номером, которая соответствует вашей спецификации или принятым стандартам; подход отличается от предшествующей модели, где выигрывала версия, установленная позже всех.
Изменение имени в первой строке сценария на python2 приводит взамен к запуску установленной версии Python 2.Х (в действительности с наибольшим номером):
# ! python2
...остальной код сценария не изменился...
C:\code> what.py # Выполняется с помощью последней версии Python 2.Х
# согласно #!
2.7.17
При необходимости можно запросить более конкретную версию интерпретатора — скажем, если вас не интересует последняя версия в линейке Python:
#! python3.1
C:\code> what.py # Выполняется с помощью версии Python 3.1 согласно #!
3.1.4
Это верно даже когда запрошенная версия не установлена, что трактуется запускающим модулем как ошибочный случай:
# ! python2.6
С: \code> what.py
Requested Python version (2.6) is not installed
Запрошенная версия Python (2.6) не установлена
Нераспознанные строки # ! также рассматриваются как ошибки, если только вы не укажете номер версии в командной строке с целью корректировки, что более подробно описано в следующем разделе:
#!/bin/python
C:\code> what.py
Unable to create process using '/bin/python "C:\code\what.py" 1 He удалось создать процесс, используя /bin/python "С:\code\what .ру”
C:\code> ру what.py
Unable to create process using '/bin/python what.py'
He удалось создать процесс, используя /bin/python what.py
C:\code> py -3 what.py
3.7.3
Формально запускающий модуль распознает строки # ! в стиле Unix, находящиеся в начале файлов сценариев, которые соответствуют одной их следующих четырех схем:
#!/usr/bin/env python*
#!/usr/bin/python*
#!/usr/local/bin/python*
#!python*
Любая строка # !, не принимающая одну из таких распознаваемых и разбираемых форм, считается полностью заданной командной строкой для запуска процесса выполнения файла, которая передается Windows без изменений и приводит к выдаче показанного ранее сообщения об ошибке, если она не является допустимой командой Windows. (Запускающий модуль через свои конфигурационные файлы также поддерживает “настраиваемые” расширения команд, которые опробуются перед передачей нераспознанных команд среде Windows, но здесь мы их не затрагиваем.)
В распознаваемых строках # ! пути к каталогам записываются в соответствии с соглашением Unix для обеспечения переносимости на эту платформу. Часть * в конце распознаваемых схем обозначает необязательный номер версии Python в одной из трех форм.
Неполный номер (например, python3)
Для запуска установленной версии, которая имеет наибольший младший номер выпуска среди версий с заданным старшим номером выпуска.
Полный номер (например, python3 .1)
Для запуска только конкретной версии; можно указать необязательный суффикс -32, чтобы выбрать 32-разрядную версию (скажем, python3.1-32)
Номер опущен (например, python)
Для запуска версии, принятой запускающим модулем в качестве стандартной.
Файлы, вообще не содержащие строк # !, ведут себя точно так же, как файлы, в строках # ! которых указано обобщенное имя python — вышеупомянутый вариант с отсутствием номера версии — и находятся под влиянием стандартных настроек PY PYTHON. Первый случай, неполный номер, также может находиться под влиянием настроек среды, специфичных к версии (например, установите PY PYTH0N3 в 3.1, чтобы для python3 выбиралась версия Python 3.1, и PY PYTH0N2 в 2 . 6, чтобы для python2 выбиралась версия Python 2.6).
Однако важно отметить, что все, находящееся после части * в формате строки # !, трактуется как аргументы командной строки самого интерпретатора Python (т.е. программы python. ехе), если только вы также не предоставите аргументы в командной строке ру, которые запускающий модуль считает заменой аргументов в строке # !: #!python3 [здесь находятся любые аргументы python, ехе]
Сюда входят все аргументы командной строки Python, которые встречались в приложении А. Но это подводит нас к командным строкам запускающего модуля в целом и является достаточным основанием для плавного перехода к следующему разделу.
Шаг 2: использование переключателей версий командной строки
Как уже упоминалось, переключатель версии в командной строке можно применять для выбора версии интерпретатора Python, если она не указана в файле. В таком случае вы вводите командную строку ру или pyw и передаете ей переключатель версии, а не полагаетесь на файловые ассоциации в реестре либо на предоставление версий в строке # ! файла (или в дополнение к нему). Ниже мы удаляем директиву # ! из нашего сценария:
# директива запускающего модуля отсутствует
C:\code> ру -3 what.py # Выполняется согласно переключателю командной строки
3.7.3
C:\code> ру -2 what.py # То же самое: последняя установленная версия Python 2.Х
2.7.17
C:\code> ру -3.2 what.py # То же самое: конкретно (и только) версия Python 3.2
3.2.3
C:\code> ру what.py # Выполняется согласно принятой в запускающем
# модуле стандартной версии
3.7.3
Но переключатели командной строки также имеют приоритет над указанием версии в директиве файла:
#! python3.1
C:\code> what.py # Выполняется в соответствии с директивой файла
3.1.4
C:\code> ру what.py # То же самое
3.1.4
C:\code> ру -3.2 what.py # Переключатели аннулируют директивы
3.2.3
C:\code> ру -2 what.py # То же самое
2.7.17
Формально запускающий модуль принимает следующие виды аргументов командной строки (которые в точности отражают часть * в конце строки # ! файла, описанную в предыдущем разделе):
-2 Запуск последней версии Python 2.Х
-3 Запуск последней версии Python З.Х
-X.Y Запуск указанной версии Python (X - это 2 или 3)
-X.Y-32 Запуск указанной 32-разрядной версии Python
И командные строки запускающего модуля принимают такую общую форму:
ру [аргумент ру. ехе] [аргументы python, ехе] script.py [аргументы script.py]
Все, что находится за собственным аргументом запускающего модуля (если он есть), трактуется как если бы оно передавалось программе python.exe — обычно сюда входят любые аргументы для самого интерпретатора Python, за которыми следует имя файла сценария и любые аргументы, предназначенные для сценария.
Привычные формы спецификации программы -ш модуль, -с команда и — тоже работают в командной строке ру, как и все остальные аргументы командной строки Python, раскрытые в приложении А. Ранее упоминалось о том, что аргументы для python. ехе также могут появляться в конце строки директивы # !, если они используются, хотя аргументы в командных строках ру их аннулируют.
Чтобы увидеть, как все работает, давайте реализуем новый сценарий, который расширяет предыдущий отображением аргументов командной строки; sys .argv является собственными аргументами сценария, и вдобавок применяется переключатель -i интерпретатора Python (python.exe), обеспечивающий открытие интерактивной подсказки (»>) после выполнения сценария:
# Файл args.py, отображает также собственные аргументы import sys
print(sys.version.split()[0]) print(sys.argv)
C:\code> py -3 -i args.py -a 1 -b -c # -3: py, -i; python, остальные: сценарий
3.7.3
['args.py', '-a', 'l1, '-b1, '-c']
»> AZ
C:\code> py -i args.py -a 1 -b -с # Аргументы для python и сценария
2.7.17
['args.py', '-a', '1', '-b', 1 -c']
»> AZ
C:\code> py -3 -c print(99) # -3 для py, остальные для python: "-с команда” 99
C:\code> py -2 -с "print 99м
99
Обратите внимание, что первые две команды запускают стандартную версию Python, если только версия не задается в командной строке, поскольку в самом сценарии отсутствует строка # !.
Выводы: чистый выигрыш для Windows
Запускающий модуль, который поставляется, начиная с Python 3.3, предлагает согласованный способ управления сценариями и установленными интерпретаторами смешанных версий. Вы наверняка сочтете запускающий модуль ценным средством, как только приступите к его использованию.
В действительности у вас также может возникнуть желание начать вырабатывать привычку к написанию совместимых с Unix строк # ! в своих сценариях для Windows, указывая явные номера версий (например, # ! /usr/bin/python3). Это не только объявляет требования вашего кода и организует его надлежащее выполнение в Windows, но также обходит принятые по умолчанию версии в запускающем модуле и в будущем способно сделать сценарий пригодным в качестве исполняемой программы Unix.
Но вы должны отдавать себе отчет, что запускающий модуль может нарушить работу прежде допустимых сценариев, содержащих строки # !, требовать конфигурирования и внесения в код изменений того вида, на избегание которых он был нацелен. Новый шеф лучше старого, но похоже на то, что они ходили в одну и ту же школу.
За дополнительными сведениями о работе с интерпретатором в Windows обращайтесь в приложение А (установка и конфигурирование), главу 3 первого тома (общие концепции) и документацию, специфичную для платформы, внутри набора руководств по Python.
Приложение В
Изменения в Python и настоящая книга
В этом приложении кратко подытоживаются изменения, которые вносились в последние выпуски Python, организованные по изданиям книги, где они впервые затрагивались. Оно задумано как справочник для читателей предшествующих изданий и разработчиков, пришедших из предыдущих выпусков Python.
Вот как изменения в Python соотносятся с изданиями книги:
• в пятом издании (2013 год) раскрываются Python 3.3 и 2.7;
• в четвертом издании (2009 год) раскрываются Python 2.6 и 3.0 (с рядом возможностей Python 3.1);
• в третьем издании (2007 год) раскрывается Python 2.5;
• в первом и во втором изданиях (1999 и 2003 годы) раскрываются Python 2.0 и 2.2;
• в предшественнике настоящей книги, Programming Python (1996 год), раскрывался Python 1.3.
Следовательно, чтобы увидеть изменения, внесенные только в пятое издание, необходимо просмотреть перечисленные далее изменения в версиях Python 2.7, 3.2 и 3.3. Для выяснения, что изменилось в четвертом, и пятом изданиях (т.е., начиная с третьего), также понадобится просмотреть изменения в версиях Python 2.6, 3.0 и 3.1. Изменения в третьем выпуске языка тоже описаны очень кратко, хотя теперь они, похоже, имеют лишь историческое значение.
Кроме того, имейте в виду, что приложение сосредоточено на крупных изменениях и их влиянии на книгу, но не предназначено служить исчерпывающим руководством по развитию Python. Более полные сведения об изменениях в каждом новом выпуске Python ищите в разделах “What’s New” (“Что нового”) стандартной документации, которая доступна по ссылке Documentation (Документация) на веб-сайте python.org. Документация и набор руководств обсуждались в главе 15 первого тома.
Главные отличия между Python 2.Х и Python З.Х
Большая часть приложения связывает изменения в Python с освещением языка в книге. Если вас интересует краткий обзор самых заметных отличий между Python 2.Х и Python З.Х, то приведенного далее материала может оказаться достаточно. Обратите внимание, что в этом разделе в основном сравниваются последние выпуски Python З.Х и Python 2.Х. Многие средства Python З.Х здесь не рассматриваются, потому что они либо были доставлены в Python 2.6 (например, оператор with и декораторы классов), либо позже перенесены в Python 2.7 (скажем, включения множеств и словарей), но не доступны в более ранних выпусках Python 2.Х.
Отличия Python З.Х
Ниже приводится сводка по инструментам, которые отличаются между линейками Python.
• Модель строк Unicode. В Python З.Х обычные строки str поддерживают весь текст Unicode, включая ASCII, а отдельный тип bytes представляет низкоуровневые последовательности 8-битных байтов. В Python 2.Х обычные строки str поддерживают 8-битный текст, включая ASCII, а отдельный тип Unicode представляет обогащенный текст Unicode как вариант.
• Модель файлов. В Python З.Х файлы, создаваемые open, специализируются по содержимому — текстовые файлы задействуют кодировки Unicode и представляют содержимое в виде строк str, а двоичные файлы представляют содержимое как строки bytes. В Python 2.Х файлы используют индивидуальные интерфейсы — файлы, создаваемые open, представляют содержимое в виде строк str для содержимого, которое является либо 8-битным текстом, либо байтовыми данными, и codecs. open задействует кодировки текста Unicode.
• Модель классов. В Python З.Х все классы автоматически становятся производными от object и обзаводятся многочисленными изменениями и расширениями классов нового стиля, включая отличающийся алгоритм наследования, координирование встроенных операций и порядок поиска MRO для деревьев с ромбовидными схемами. В Python 2.Х нормальные классы следуют классической модели, а явное наследование от obj ect или других встроенных типов запускает в работу модель нового стиля как вариант.
• Встроенные ттьерируемые объекты. В Python З.Х встроенные вызовы шар, zip, range, filter, а также атрибуты keys, values и items словарей возвращают итерируемые объекты, которые генерируют значения по запросу. В Python 2.Х все эти вызовы создают физические списки.
• Вывод. В Python З.Х предоставляется встроенная функция с ключевыми аргументами для конфигурирования, тогда как в Python 2.Х предлагается оператор со специальным синтаксисом для конфигурирования.
• Относительное импортирование. В Python 2.Х и Python З.Х поддерживаются операции относительного импортирования from ., но в Python З.Х изменилось правило поиска, чтобы пропускать собственный каталог пакета для нормальных операций импортирования.
• Настоящее деление. В Python 2.Х и Python З.Х поддерживается операция деления с округлением в меньшую сторону //, но в Python З.Х операция / является настоящим делением и предохраняет дробные остатки, тогда как в Python 2.Х операция / специфична к типу.
• Целочисленные типы. В Python З.Х есть единственный целочисленный тип, который поддерживает расширенную точность. В Python 2.Х имеется тип int с нормальной и тип long с расширенной точностью, а также обеспечивается автоматическое преобразование в long.
• Области видимости включений, В Python З.Х все формы включений — списка, множества, словаря, генератор — локализуют переменные в выражении. В Python
2.Х списковые включения этого не делают.
• PyDoc. Начиная с Python 3.2, поддерживается интерфейс с единым браузером pydoc -b, который стал обязательным в Python 3.3 и последующих версиях. В Python 2.Х взамен может применяться первоначальный клиент с графическим пользовательским интерфейсом pydoc -д.
• Хранение файлов с байт-кодом. Начиная с версии Python 3.2, файлы с байт-кодом
хранятся в подкаталоге_pycache_каталога с исходным кодом и получают
имена, идентифицирующие версию. В Python 2.Х файлы с байт-кодом хранятся в каталоге с исходным кодом и имеют обобщенные имена.
• Встроенные системные исключения. В версии Python 3.3 была переделана иерархия исключений для классов операционной системы и ввода-вывода, чтобы поддерживать дополнительные категории и детализацию. В Python 2.Х иногда должны проверяться атрибуты исключений на предмет возникновения системных ошибок.
• Сравнения и сортировки. В Python З.Х сравнения по абсолютной величине для разнородных типов и словарей являются ошибками, а сортировки не поддерживают разнородные типы или универсальные функции сравнения. В Python 2.Х все указанные формы работают.
• Исключения на основе строк и функции модуля string. Исключения на основе строк были удалены в Python З.Х, а также исчезли в Python 2.Х, начиная с версии Python 2.6 (взамен должны использоваться классы). Функции модуля string, избыточные из-за наличия методов строковых объектов, также были удалены в Python З.Х.
• Удаления в языке. Как показано в табл. В.2, в Python З.Х удалены, переименованы или перемещены многих языковые элементы Python 2.Х: reload, apply, 'xv, о, 0177, 999L, diet.has_key, raw_input, xrange, file, reduce и file.xreadlines.
Расширения, доступные только в Python З.Х
Ниже приведена сводка по инструментам, доступным только в Python З.Х.
• Расширенные присваивания последовательностей. В Python З.Х разрешено применять
* в целях операций присваивания последовательностей для накопления в списке элементов итерируемых объектов, оставшихся несопоставленными. В Python
2.Х похожих результатов можно добиться с помощью нарезания.
• Оператор nonlocal. В Python З.Х предлагается оператор nonlocal, который позволяет изменять имена из областей видимости объемлющих функций внутри вложенных функций. В Python 2.Х похожих результатов можно добиться посредством атрибутов функций, изменяемых объектов и состояния классов.
• Аннотации функций. В Python З.Х предоставляется возможность аннотировать аргументы и возвращаемые типы функций с помощью объектов, которые хранятся в функции, но иным способом не используются. В Python 2.Х похожих результатов часто можно достичь посредством дополнительных объектов или аргументов декораторов.
• Аргументы с передачей только по ключевым словам. В Python З.Х разрешено определение аргументов функций, которые обязаны передаваться как ключевые слова, обычно применяемые для добавочных конфигурационных параметров. В Python 2.Х похожих результатов часто можно добиться с помощью анализа аргументов и извлечений из словаря.
• Сцепленные исключения. В Python З.Х посредством расширения raise from исключения можно объединять в цепочки, обеспечивая тем самым их присутствие в сообщениях об ошибках; начиная с версии Python 3.3, указание None позволяет аннулировать цепочку.
• Оператор yield from. Начиная с версии Python 3.3, оператор yield с помощью конструкции from может делегировать работу вложенному генератору. В Python 2.Х посредством цикла for часто можно достичь похожих результатов для более простых сценариев использования.
• Пакеты пространств имен. Начиная с версии Python 3.3, модель пакетов была расширена, чтобы позволить пакетам охватывать множество каталогов без файла инициализации в качестве запасного варианта. В Python 2.Х похожих результатов можно добиться с помощью расширений импортирования.
• Запускающий модуль Windows. Начиная с версии Python 3.3, вместе с интерпретатором поставляется запускающий модуль Windows, хотя он также доступен отдельно для применения с другими версиями Python, включая Python 2.Х.
• Внутреннее устройство. Начиная с версии Python 3.2, многопоточная работа реализована с использованием временных интервалов вместо счетчиков команд виртуальной машины. Начиная с версии Python 3.3, текст Unicode сохраняется с применением схемы с переменной длиной, а не байтов фиксированного размера. Модель строк Python 2.Х в целом сводит к минимуму использование Unicode.
Общие замечания: изменения в Python З.Х
Несмотря на то что линейка Python З.Х, раскрываемая в последних двух изданиях этой книги, представляет собой почти тот же самый язык, что и предшествующая ей линейка Python 2.Х, в ряде ключевых областей существуют отличия. Как обсуждалось в предисловии к первому тому и подытоживалось в предыдущем разделе, не являющаяся факультативной модель Unicode, обязательные классы нового стиля и больший акцент на генераторах и других инструментах функционального программирования в линейке Python З.Х способны сделать работу с ней принципиально другой.
В общем и целом Python З.Х может считаться более чистым языком, но во многих отношениях он также и более сложный язык, опирающийся на значительно более развитые концепции. Фактически некоторые изменения предполагают, что для изучения Python вы уже должны знать Python. В предисловии к первому тому уминались самые заметные циклические зависимости внутри знаний в Python З.Х, которые влекут за собой прямые тематические зависимости.
Рассмотрим произвольный пример. Логическое обоснование для помещения словарных представлений внутрь вызова list в Python З.Х чрезвычайно тонкое и требует наличия солидных предварительных знаний — самое меньшее представлений, генераторов и протокола итерации. Ключевые аргументы аналогичным образом обязательны в простых инструментах (скажем, вывод, форматирование строк, создание словарей и сортировка), которые встречаются задолго до того, как новоприбывший получит достаточные знания о функциях, чтобы полностью понять их. Одной из целей книги было оказание помощи в преодолении такой бреши в знаниях, присущей современному миру с двумя линейками Python 2.Х и Python З.Х.
Изменения в библиотеках и инструментах
В Python З.Х были внесены дополнительные изменения, которые в настоящем приложении не рассматриваются просто потому, что они не оказывают влияния на книгу. Например, ряд стандартных библиотечных средств и инструментов разработки выходят за рамки тематики основного языка, обсуждаемой в книге, хотя некоторые из них упоминались попутно (скажем, timeit), а другие раскрывались здесь всегда (например, PyDoc).
Для полноты в последующих разделах отмечаются наработки Python З.Х в таких категориях. Позже в приложении будут описаны изменения, внесенные в данные категории, с указанием издания книги и версии Python, где они были представлены.
Изменения в стандартной библиотеке
Говоря формально, стандартная библиотека Python не является частью тематики основного языка, которой посвящена эта книга, хотя она всегда доступна с Python и буквально пронизывает реалистичные программы на Python. На самом деле библиотеки не подпадали под действие временного моратория на языковые изменения Python
З.Х, установленного во время разработки версии Python 3.2.
Из-за этого изменения в стандартной библиотеке оказывают более сильное воздействие на книги, ориентированные на разработку прикладных приложений, вроде Programming Python (http: //shop. oreilly. com/product/9780596158118 .do). Хотя большая часть функциональности стандартной библиотеки по-прежнему остается на месте, в Python З.Х продолжилось переименование модулей, группирование их в пакеты и изменение схем обращения к API-интерфейсам.
Однако некоторые изменения в библиотеке оказываются гораздо более широкими. Например, модель Unicode в Python З.Х становится причиной широко распространенных отличий стандартной библиотеки — она потенциально влияет на любую программу, обрабатывающую содержимое файлов, имена файлов, средства прохода по каталогам, каналы, дескрипторные файлы, сокеты, текст в графических пользовательских интерфейсах, протоколы Интернета, такие как FTP и электронная почта, сценарии CGI, веб-содержимое многих видов и даже ряд инструментов для постоянства, в том числе файлы DBM, shelve и pickle.
Более полный список изменений в стандартной библиотеке Python З.Х представлен в разделах “What’s New” документации для выпусков Python З.Х (особенно Python 3.0). Из-за повсеместного применения Python З.Х книга Programming Python также может служить руководством по изменениям в стандартной библиотеке Python З.Х.
Изменения в инструментах
Хотя большинство инструментов разработки одинаковы в Python 2.Х и Python З.Х (скажем, инструментов для отладки, профилирования, измерения времени и тестирования), в Python З.Х некоторые из них претерпели изменения вместе с языком и стандартной библиотекой. Например, система документирования модулей PyDoc отошла от своей прежней модели клиента с графическим пользовательским интерфейсом в Python 3.2 и предшествующих версиях, заменив ее интерфейсом с единым браузером.
В данной категории есть и другие изменения, заслуживающие внимания. Пакет distutils, используемый для распространения и установки стороннего программного обеспечения, в Python З.Х заменен новой системой пакетирования. Описанная в книге новая схема хранения файлов с байт-кодом в_ру cache_, хотя и является
усовершенствованием, способна повлиять на многие инструменты Python и программы. Начиная с версии Python 3.2, внутренняя реализация многопоточной обработки изменилась для сокращения состязаний за счет модификации глобальной блокировки интерпретатора (OIL), чтобы применять временные интервалы вместо счетчика команд виртуальной машины.
Переход на Python З.Х
Если вы переходите из Python 2.Х на Python З.Х, тогда обязательно ознакомьтесь со сценарием 2to3 для автоматического преобразования кода, который поставляется в составе Python З.Х. В текущий момент он доступен в подкаталоге Tools\Scripts каталога с установленной копией Python. Сценарий 2to3 не способен транслировать абсолютно все и пытается переводить главным образом код на основном языке — API-интерфейсы стандартной библиотеки Python З.Х могут дополнительно отличаться. Тем не менее, он делает приличную работу по преобразованию большей части кода на Python 2.Х для выполнения под управлением Python З.Х.
Наоборот, программа обратного преобразования 3to2, в настоящее время доступная в области стороннего программного обеспечения, может транслировать большинство кода на Python З.Х для запуска в средах Python 2.Х. В зависимости от имеющихся целей и ограничений программа 2to3 или 3to2 может оказаться полезной, если вы обязаны поддерживать код для обеих линеек Python; ищите в веб-сети детали, а также дополнительные инструменты и методики.
Можно также написать код, который выполняется переносимым образом в Python 2.Х и Python З.Х, с использованием методик, представленных в книге — импортирование средств Python З.Х из модуля ____future_, избегание специфичных для версии инструментов и т.д. Многие примеры, рассмотренные в книге, нейтральны к платформе. К ним относятся инструменты для оценки из главы 21 первого тома, инструменты для перезагрузки и форматирования из главы 25 первого тома, инструменты для вывода деревьев классов из главы 31, большинство крупных примеров декораторов из глав 38 и 39, шуточный сценарий в конце главы 41 и многое другое. До тех пор, пока вы понимаете основные языковые отличия Python 2.X/Python З.Х, реализация переносимого кода часто прямолинейна.
Если вас интересует написание кода для Python 2.Х и Python З.Х, тогда взгляните также на six — библиотеку не зависящих от версии инструментов отображения и переименования, которая в текущее время расположена по ссылке .
Естественно, данный пакет не может скомпенсировать все отличия в семантике языка и API-интерфейсах библиотеки, и во многих случаях для получения преимуществ переносимости вам придется применять инструменты его библиотеки вместо чистого Python. Однако взамен ваши программы станут более нейтральными к версии.
