WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 | 3 | 4 | 5 |   ...   | 7 |
-- [ Страница 1 ] --

Г. Россум, Ф.Л.Дж. Дрейк, Д.С. Откидач Язык программирования Python Г. Россум, Ф.Л.Дж. Дрейк, Д.С. Откидач, М. Задка, М. Левис, С. Монтаро, Э.С. Реймонд, А.М. Кучлинг, М.-А. Лембург, К.-П. Йи, Д. Ксиллаг,

Х.Г. Петрилли, Б.А. Варсав, Дж.К. Ахлстром, Дж. Роскинд, Н. Шеменор, С. Мулендер. Язык программирования Python. / 2001 — 454 c.

Python является простым и, в то же время, мощным интерпретируемым объектно ориентированным языком программирования. Он предоставляет структуры данных вы сокого уровня, имеет изящный синтаксис и использует динамический контроль типов, что делает его идеальным языком для быстрого написания различных приложений, ра ботающих на большинстве распространенных платформ. Книга содержит вводное руко водство, которое может служить учебником для начинающих, и справочный материал с подробным описанием грамматики языка, встроенных возможностей и возможностей, предоставляемых модулями стандартной библиотеки. Описание охватывает наиболее распространенные версии Python: от 1.5.2 до 2.0.

© Stichting Mathematisch Centrum, 1990– © Corporation for National Research Initiatives, 1995– © BeOpen.com, © Д.С. Откидач, Дорогой читатель!

Вашему вниманию предлагается книга “Язык программирования Python”.

Книга эта — не просто перевод английского учебника. Автор перевода проделал огромную работу по проверке примеров и упражнений, добавил в книгу немало дру гих материалов.

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

Python — это свободный интерпретируемый объектно-ориентированный рас ширяемый встраиваемый язык программирования очень высокого уровня.

– свободный — все исходные тексты интерпретатора и библиотек доступны для любого, включая коммерческое, использования;

– интерпретируемый — потому что использует “позднее связывание”;

– объектно-ориентированный — классическая ОО модель, включая множествен ное наследование;

– расширяемый — имеет строго определенные API для создания модулей, типов и классов на C или C++;

– встраиваемый — имеет строго определенные API для встраивания интерпре татора в другие программы;

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

Python — язык универсальный, он широко используется во всем мире для са мых разных целей — базы данных и обработка текстов, встраивание интерпре татора в игры, программирование GUI и быстрое создание прототипов (RAD).

И, конечно же, Python используется для программирования Internet и Web прило жений — серверных (CGI), клиентских (роботы), Web-серверов и серверов прило жений. Python обладает богатой стандартной библиотекой, и еще более богатым набором модулей, написанных третьими лицами. Python и приложения, написанные на нем, используют самые известные и крупные фирмы — IBM, Yahoo!, Google.com, Hewlett Packard, Infoseek, NASA, Red Hat, CBS MarketWatch, Microsoft.

На этом языке написаны:

– Mailman — менеджер списков рассылки (mailing list manager), ставший офи циальным менеджером списков рассылки проекта GNU;

– Medusa — архитектура для высокопроизводительных надежных TCP/IP серверов, таких как HTTP, FTP, NNTP, XML-RPC и SOAP;

– Zope — сервер Web-приложений (Web application server), приобретший широ кую популярность.

Python используется и в России. Многие компании используют его для вну тренних нужд;

на этом языке пишутся утилиты, фильтры, резидентные програм мы, GUI и Web-сайты. На некоторых сайтах все CGI-программы написаны на языке Python (сайт Фонда “Общественное мнение” www.fom.ru), другие используют систе мы публикации, написанные на языке Python (Русский Журнал, www.russ.ru). Нахо дит использование и Zope. На нем сделаны сайты: Каталог Full.RU (www.full.ru), Банк МЕНАТЕП СПб (www.menatep.spb.ru), сайт красноярской компании Интербит (www.interbit.ru) и другие.

Существует русскоязычная группа пользователей Python и Zope, сайт ко торой (zope.net.ru) также построен на технологии Zope. Группа имеет список рассылки, в котором обсуждаются вопросы и решаются проблемы, связанные с использованием Python и Zope.

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

Денис Откидач Оглавление BEOPEN.COM TERMS AND CONDITIONS FOR PYTHON 2.0 I Вводное руководство 1 Разжигая Ваш аппетит 2 Использование интерпретатора 2.1 Вызов интерпретатора.............................. 2.1.1 Передача аргументов.......................... 2.1.2 Интерактивный режим......................... 2.2 Интерпретатор и его среда........................... 2.2.1 Обработка ошибок........................... 2.2.2 Исполняемые файлы.......................... 2.2.3 Инициализация при запуске в интерактивном режиме....... 3 Неформальное введение в Python 3.1 Использование интерпретатора Python в качестве калькулятора...... 3.1.1 Числа................................... 3.1.2 Строки.................................. 3.1.3 Строки Unicode............................. 3.1.4 Списки.................................. 3.2 Первые шаги к программированию....................... 4 Средства управления логикой 4.1 Инструкция if.................................. 4.2 Инструкция for................................. 4.3 Функции range() и xrange()........................ 4.4 Инструкции break и continue, ветвь else в циклах........... 4.5 Инструкция pass................................ 4.6 Определение функций.............................. 4.7 Дополнительные возможности в определении функций........... 4.7.1 Значения аргументов по умолчанию................. 4.7.2 Произвольный набор аргументов................... 4.7.3 Именованные аргументы........................ 4.7.4 Короткая форма............................. 4.7.5 Строки документации.......................... 4.7.6 Вызов функций............................. 5 Структуры данных 5.1 Подробнее о списках............................... 5.1.1 Стеки................................... 5.1.2 Очереди................................. 6 Оглавление 5.2 Средства функционального программирования................ 5.3 Дополнительные возможности при конструировании списков....... 5.4 Инструкция del................................. 5.5 Кортежи...................................... 5.6 Словари...................................... 5.7 Подробнее об условиях............................. 5.8 Сравнение последовательностей........................ 6 Модули 6.1 Создание и использование модулей....................... 6.2 Поиск модулей.................................. 6.3 “Компилированные” файлы........................... 6.4 Стандартные модули............................... 6.5 Функция dir()................................. 6.6 Пакеты....................................... 6.6.1 Импортирование всего содержимого пакета (модуля)........ 6.6.2 Связи между модулями пакета..................... 7 Ввод/вывод 7.1 Форматированный вывод............................ 7.2 Чтение и запись файлов............................. 7.2.1 Методы объектов-файлов........................ 7.2.2 Модуль pickle............................. 8 Ошибки и исключения 8.1 Синтаксические ошибки............................. 8.2 Исключения.................................... 8.3 Обработка исключений............................. 8.4 Генерация исключений............................. 8.5 Исключения, определяемые пользователем.................. 8.6 “Страхование” от ошибок............................ 9 Классы 9.1 Несколько слов о терминологии........................ 9.2 Области видимости и пространства имен................... 9.3 Первый взгляд на классы............................ 9.3.1 Синтаксис определения класса.................... 9.3.2 Объекты-классы............................. 9.3.3 Объекты-экземпляры.......................... 9.3.4 Методы экземпляров классов..................... 9.4 Выборочные замечания............................. 9.5 Наследование................................... 9.6 Частные атрибуты................................ 9.7 Примеры использования классов........................ 9.7.1 Экземпляры классов в качестве исключений............. 9.7.2 Классы-помощники........................... 9.7.3 Множества................................ 9.7.4 Контроль доступа к атрибутам..................... Оглавление II Встроенные возможности языка 10 Синтаксис и семантика 10.1 Структура строк программы........................... 10.1.1 Логические и физические строки.................... 10.1.2 Отступы................................. 10.2 Выражения.................................... 10.2.1 Атомы................................... 10.2.2 Первичные выражения......................... 10.2.3 Арифметические и битовые операторы................ 10.2.4 Условные операторы.......................... 10.2.5 Истинность................................ 10.2.6 Логические операторы......................... 10.2.7 Оператор lambda............................ 10.2.8 Списки выражений........................... 10.2.9 Сводная таблица приоритетов..................... 10.3 Простые инструкции............................... 10.3.1 Инструкции-выражения......................... 10.3.2 Присваивание.............................. 10.3.3 Инструкция del............................. 10.3.4 Пустая инструкция........................... 10.3.5 Инструкция print........................... 10.3.6 Инструкция break........................... 10.3.7 Инструкция continue......................... 10.3.8 Инструкция return.......................... 10.3.9 Инструкция global.......................... 10.3.10 Инструкция import.......................... 10.3.11 Инструкция exec............................ 10.3.12 Отладочные утверждения....................... 10.3.13 Генерация исключений......................... 10.4 Составные инструкции.............................. 10.4.1 Инструкция if............................. 10.4.2 Цикл while............................... 10.4.3 Цикл for................................. 10.4.4 Инструкция try............................. 10.4.5 Определение функций......................... 10.4.6 Определение класса........................... 10.5 Пространства имен................................ 11 Встроенные типы данных 11.1 Числовые типы.................................. 11.1.1 Целые и длинные целые числа..................... 11.1.2 Вещественные числа.......................... 11.1.3 Комплексные числа........................... 11.1.4 Арифметические операторы...................... 11.1.5 Битовые операции над целыми числами............... 11.2 Последовательности............................... 11.2.1 Строки.................................. 8 Оглавление 11.2.2 Строки Unicode............................. 11.2.3 Кортежи................................. 11.2.4 Объекты xrange............................ 11.2.5 Объекты buffer............................ 11.2.6 Изменяемые последовательности................... 11.3 Отображения................................... 11.4 Объекты, поддерживающие вызов....................... 11.4.1 Функции, определенные пользователем................ 11.4.2 Методы, определенные пользователем................ 11.4.3 Встроенные функции и методы.................... 11.4.4 Классы.................................. 11.4.5 Экземпляры классов.......................... 11.5 Модули...................................... 11.6 Классы и экземпляры классов......................... 11.6.1 Классы.................................. 11.6.2 Экземпляры классов.......................... 11.6.3 Специальные методы.......................... 11.7 Файловые объекты................................ 11.8 Вспомогательные объекты............................ 11.8.1 Пустой объект.............................. 11.8.2 Объекты типа.............................. 11.8.3 Представление расширенной записи среза.............. 11.9 Детали реализации................................ 11.9.1 Объекты кода.............................. 11.9.2 Кадр стека................................ 11.9.3 Объекты traceback.......................... 12 Встроенные функции 13 Встроенные классы исключений III Библиотека стандартных модулей 14 Конфигурационные модули 14.1 site — общая конфигурация.......................... 14.2 user — конфигурация пользователя...................... 15 Служебные модули 15.1 sys — характерные для системы параметры и функции........... 15.2 gc — управление “сборщиком мусора”.................... 15.3 atexit — выполнение действий при окончании работы программы.... 15.4 types — имена для всех встроенных типов.................. 15.5 operator — операторы в виде функций................... 15.6 traceback — модуль для работы с объектами traceback........ 15.7 imp — доступ к операциям, производимым инструкцией import..... 15.8 pprint — представление и вывод данных в более привлекательном виде 15.9 repr — альтернативная реализация функции repr()............ Оглавление 16 Работа со строками 16.1 string — наиболее распространенные операции над строками...... 16.2 re — операции с регулярными выражениями................. 16.2.1 Синтаксис регулярных выражений.................. 16.2.2 Сопоставление в сравнении с поиском................ 16.2.3 Функции и константы, определенные в модуле........... 16.2.4 Объекты, представляющие регулярные выражения......... 16.2.5 Объекты, представляющие результат сопоставления........ 16.3 StringIO и cStringIO — работа со строками как с файловыми объектами 16.4 codecs — регистрация кодеров и работа с ними............... 17 Средства интернационализации 17.1 locale — использование национальных особенностей........... 17.2 gettext — выдача сообщений на родном языке............... 17.2.1 Интерфейс GNU gettext......................... 17.2.2 Интерфейс, основанный на классах.................. 17.2.3 Изготовление каталога переведенных сообщений.......... 18 Математический аппарат 18.1 math — математические функции для работы с вещественными числами. 18.2 cmath — математические функции для работы с комплексными числами. 18.3 random — псевдослучайные числа с различными распределениями.... 18.4 whrandom — генератор псевдослучайных чисел............... 18.5 bisect — поддержание последовательностей в сортированном состоянии 18.6 array — эффективные массивы чисел..................... 19 Интерфейсные классы к встроенным типам 19.1 UserString — интерфейсный класс для создания строковых объектов. 19.2 UserList — интерфейсный класс для создания последовательностей.. 19.3 UserDict — интерфейсный класс для создания отображений....... 20 Сохранение и копирование объектов 20.1 pickle и cPickle — представление объектов в виде последовательно сти байтов..................................... 20.2 shelve — сохранение объектов в базе данных в стиле DBM........ 20.3 marshal — байт-компилированное представление объектов........ 20.4 struct — преобразование объектов в структуры языка C......... 21 Доступ к средствам, предоставляемым операционной системой 21.1 os — основные службы операционной системы................ 21.1.1 Параметры процесса.......................... 21.1.2 Создание файловых объектов..................... 21.1.3 Операции с файловыми дескрипторами................ 21.1.4 Файлы и каталоги............................ 21.1.5 Управление процессами........................ 21.1.6 Различная системная информация.................. 21.2 os.path — работа с именами путей...................... 21.3 stat — интерпретация os.stat()...................... 10 Оглавление 21.4 statvfs — интерпретация os.statvfs()................. 21.5 filecmp — сравнение файлов и каталогов.................. 21.6 popen2 — доступ к потокам ввода/вывода дочерних процессов...... 21.7 time — определение и обработка времени.................. 21.8 sched — планирование задач.......................... 21.9 getpass — запрос пароля и определение имени пользователя....... 21.10 getopt — обработка опций в командной строке............... 21.11 tempfile — создание временных файлов................... 21.12 errno — символические имена стандартных системных ошибок...... 21.13 glob — раскрытие шаблона имен путей.................... 21.14 fnmatch — сопоставление имен файлов с шаблоном............ 21.15 shutil — операции над файлами высокого уровня............. 21.16 signal — обработка асинхронных событий................. 21.17 socket — сетевой интерфейс низкого уровня................ 21.18 select — ожидание завершения ввода/вывода............... 21.19 mmap — отображение файлов в память.................... 22 Средства организации многопоточных программ 22.1 thread — создание нескольких потоков и управление ими......... 22.2 threading — средства высокого уровня организации потоков....... 22.2.1 Объекты, реализующие блокировку.................. 22.2.2 Условия.................................. 22.2.3 Семафоры................................. 22.2.4 События.................................. 22.2.5 Объекты, представляющие потоки................... 22.3 Queue — синхронизированные очереди.................... 23 Работа с базами данных 23.1 Интерфейс к базам данных в стиле DBM................... 23.1.1 Общая для всех модулей часть интерфейса.............. 23.1.2 Дополнительные методы объектов, возвращаемых функцией dbhash.open()............................. 23.1.3 Дополнительные методы объектов, возвращаемых функцией gdbm.open().............................. 23.2 whichdb — определение формата файла базы данных............ 23.3 bsddb — интерфейс к библиотеке баз данных BSD............. 24 Сжатие данных 24.1 zlib — алгоритм сжатия, совместимый с gzip................ 24.2 gzip — работа с файлами, сжатыми программой gzip........... 24.3 zipfile — работа с zip-архивами....................... 25 Отладка и оптимизация кода на языке Python 25.1 Отладчик кода на языке Python......................... 25.1.1 Функции запуска отладчика...................... 25.1.2 Команды отладчика........................... 25.2 Замер производительности........................... 25.2.1 Введение................................. Оглавление 25.2.2 profile — замер производительности................ 25.2.3 pstats — обработка статистических данных и вывод отчетов.. 26 Выполнение в защищенном режиме 26.1 rexec — основные средства настройки защищенного режима....... 26.2 Bastion — ограничение доступа к экземплярам классов.......... 27 Поддержка протоколов Internet 27.1 cgi — протокол CGI............................... 27.1.1 Введение................................. 27.1.2 Использование модуля cgi...................... 27.1.3 Дополнительные возможности модуля................. 27.1.4 Вопросы безопасности.......................... 27.1.5 Установка CGI-программы........................ 27.1.6 Отладка.................................. 27.2 urllib — чтение произвольных ресурсов по URL.............. 27.3 urlparse — операции над URL........................ 28 Поддержка форматов, используемых в Internet 28.1 rfc822 — обработка заголовков электронных писем............ 28.2 mimetools — обработка сообщений в формате MIME........... 28.3 MimeWriter — средства для записи в формате MIME........... 28.4 multifile — чтение сообщений, состоящих из нескольких частей.... 28.5 xdrlib — представление данных в формате XDR.............. 29 Средства работы с языками структурной разметки 29.1 sgmllib — обработка SGML-документов................... 29.2 htmllib — обработка HTML-документов................... 29.3 htmlentitydefs — определения сущностей HTML............ 29.4 xml.parsers.expat — быстрая обработка XML-документов с помощью библиотеки Expat................................ 29.5 xml.sax — SAX2 интерфейс к синтаксическим анализаторам XML документов..................................... 29.6 xml.sax.handler — базовые классы для обработчиков SAX-событий.. 29.6.1 Интерфейс класса ContentHandler................. 29.6.2 Интерфейс класса DTDHandler.................... 29.6.3 Интерфейс класса ErrorHandler.................. 29.6.4 Интерфейс класса EntityResolver................. 29.7 xml.sax.saxutils — вспомогательные средства для приложений, ис пользующих SAX................................. 29.8 xml.sax.xmlreader — интерфейс объектов, реализующих чтение и синтаксический анализ XML-документов.................... 29.8.1 Интерфейс класса XMLReader.................... 29.8.2 Интерфейс класса IncrementalParser.............. 29.8.3 Интерфейс класса Locator...................... 29.8.4 Экземпляры класса InputSource.................. 29.8.5 Экземпляры классов AttributesImpl и AttributesNSImpl. 12 Оглавление 29.9 xmllib — обработка XML-документов.................... 30 Разное 30.1 fileinput — перебор строк из нескольких входных потоков....... 30.2 ConfigParser — чтение конфигурационных файлов............ 30.3 shlex — простой синтаксический анализатор................ 30.4 cmd — создание командных интерпретаторов................. 30.5 calendar — функции для работы с календарем............... Приложения A Параметры командной строки интерпретатора и переменные окружения B Грамматика языка Указатель модулей Предметный указатель BEOPEN.COM TERMS AND CONDITIONS FOR PYTHON 2. BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1. This LICENSE AGREEMENT is between BeOpen.com (“BeOpen”), having an office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization (“Licensee”) accessing and otherwise using this software in source or binary form and its associated documentation (“the Software”).

2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that the BeOpen Python License is retained in the Software, alone or in any derivative version prepared by Licensee.

3. BeOpen is making the Software available to Licensee on an “AS IS” basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.

BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

5. This License Agreement will automatically terminate upon a material breach of its terms and conditions.

6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party. As an exception, the “BeOpen Python” logos available at http://www.pythonlabs.com/logos.html may be used according to the permissions granted on that web page.

14 BEOPEN.COM TERMS AND CONDITIONS FOR PYTHON 2. 7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement.

CNRI OPEN SOURCE LICENSE AGREEMENT Python 1.6 is made available subject to the terms and conditions in CNRI’s License Agreement. This Agreement together with Python 1.6 may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1012. This Agreement may also be obtained from a proxy server on the Internet using the following URL: http://hdl.handle.net/1895.22/1012.

CWI PERMISSIONS STATEMENT AND DISCLAIMER Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands.

All rights reserved.

Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Часть I Вводное руководство Глава Разжигая Ваш аппетит Если Вы когда-либо писали большие shell-сценарии, Вам, возможно, знакомо чувство:

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

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

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

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

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

Python — интерпретируемый язык, что позволит Вам сэкономить значительное количество времени, обычно расходуемого на компиляцию. Интерпретатор можно ис пользовать интерактивно, что позволяет экспериментировать с возможностями языка, писать наброски программ или тестировать функции при разработке “снизу вверх”. Он также удобен в качестве настольного калькулятора.

Python позволяет писать очень компактные и удобочитаемые программы. Програм мы, написанные на языке Python, обычно значительно короче эквивалента на C или 18 Глава 1. Разжигая Ваш аппетит ++ C по нескольким причинам:

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

• группирование инструкций выполняется с помощью отступов вместо фигурных ско бок;

• нет необходимости в объявлении переменных.

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

Кстати, язык назван в честь шоу BBC “Monty Python’s Flying Circus” и не имеет ничего общего с мерзкими рептилиями.

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

Глава Использование интерпретатора 2.1 Вызов интерпретатора Если расположение исполняемого файла Python включено в пути поиска, то для его запуска достаточно набрать команду python Для выхода из интерпретатора необходимо набрать символ конца файла EOF (Ctrl-D в UNIX, Ctrl-Z в DOS и Windows) когда отображается первичное приглашение. Если это не работает, Вы можете набрать команду ‘import sys;

sys.exit()’.

Интерпретатор ведет себя подобно UNIX shell: если его стандартный ввод соединен с терминалом — читает и исполняет команды интерактивно;

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

Еще одним способом использования интерпретатора является вызов ‘python -c command [arg... ]’. В этом случае исполняются одна или несколько инструкций в команде command, аналогично использованию опции -c в UNIX shell. Так как ин струкции в языке Python часто содержат пробелы, воспринимаемые как разделитель аргументов, а также другие специальные символы, лучше всего заключать command полностью в двойные кавычки.

Следует заметить, что есть разница между ‘python file’ и ‘python < file’. В последнем случае, запросы на ввод, такие как input() и raw_input() будут удовле творяться из файла. Так как файл уже будет прочитан, прежде чем программа начнет исполняться, программа немедленно получит EOF. В первом же случае (который Вам обычно и будет нужен), ввод осуществляется из устройства, с которым соединен стан дартный ввод интерпретатора Python.

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

20 Глава 2. Использование интерпретатора 2.1.1 Передача аргументов Имя исполняемого файла (программы) и дополнительные аргументы передаются про грамме в переменной sys.argv, которая является списком строк. Его длина (количе ство элементов в списке) всегда больше или равна единице. Имя программы хранится в sys.argv[0]. В интерактивном режиме sys.argv[0] содержит пустую строку. Если же имя программы передано как ‘-’ (имея в виду стандартный ввод) или интерпрета тор запущен с опцией -c, то значение sys.argv[0] устанавливается в ’-’ и ’-c’ соответственно. Все, что указывается после -c command не воспринимается как оп ции интерпретатором Python, а передается в sys.argv для обработки инструкциями в command.

2.1.2 Интерактивный режим Когда команды считываются с терминала, говорят, что интерпретатор находится в ин терактивном режиме. В этом режиме для ввода последующих команд выводится пер вичное приглашение, обычно три знака больше (‘>>> ’);

для продолжения ввода неза конченных инструкций выводится вторичное приглашение, по умолчанию — три точки (‘... ’). При запуске в интерактивном режиме интерпретатор выводит приветственное сообщение — номер версии и замечания об авторском праве — перед выводом первич ного приглашения, например:

$ python Python 2.0 (#8, Oct 16 2000, 17:27:58) [MSC 32 bit (Intel)] on win Type "copyright", "credits" or "license" for more information.

>>> Продолжение ввода незаконченных инструкций необходимо при вводе многострочных конструкций. В качестве примера, взгляните на инструкцию if:

>>> the_world_is_flat = >>> #,... if the_world_is_flat:

... print ", !"...

, !

2.2. Интерпретатор и его среда 2.2 Интерпретатор и его среда 2.2.1 Обработка ошибок При возникновении ошибки интерпретатор печатает сообщение и остаток содержимо го стека. В интерактивном режиме, после этого снова выдается первичное приглаше ние. Если программа читается из файла, интерпретатор печатает сообщение об ошибке, остаток содержимого стека и выходит с ненулевым кодом завершения. (Исключения, перехваченные ветвью except в инструкции try, не являются ошибками в данном кон тексте.) Некоторые ошибки — внутренние противоречия и некоторые случаи нехватки памяти — являются безусловно фатальными и приводят к выходу с ненулевым значе нием. Все сообщения об ошибках выводятся в стандартный поток ошибок;

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

Нажатие прерывающей комбинации клавиш (обычно Ctrl-C) во время выполнения генерирует исключение KeyboardInterrupt, которое может быть обработано с помо щью инструкции try.

2.2.2 Исполняемые файлы В операционных системах UNIX программу на языке Python можно сделать исполняемой непосредственно, поместив, например, строку #!/usr/bin/env python (подразумевая, что путь к интерпретатору включен в переменную окружения PATH пользователя) и установив разрешение на исполнение. Символы ‘#!’ должны быть пер выми двумя символами файла. Заметьте, что символ ‘#’ в языке Python используется для обозначения комментария.

2.2.3 Инициализация при запуске в интерактивном режиме Если Вы используете Python интерактивно, часто удобно иметь стандартный набор ко манд, исполняемых при каждом запуске интерпретатора. Для этого нужно присвоить переменной окружения PYTHONSTARTUP имя файла, содержащего команды инициа лизации (аналогично ‘.profile’ для UNIX shell).

Указанный файл читается только в интерактивном режиме и не используется, если команды читаются из файла, через конвейер или если терминал явно указан в качестве источника. Инициализационный файл исполняется в том же пространстве имен, что и интерактивные команды, то есть определенные в нем объекты и импортированные моду ли могут быть использованы далее без каких-либо ограничений. В этом файле Вы также можете переопределить первичное (sys.ps1) и вторичное (sys.ps2) приглашения.

22 Глава 2. Использование интерпретатора Если Вы хотите считывать дополнительно инициализационный файл из текущего каталога, следует включить соответствующие инструкции в глобальный инициализаци онный файл, например:

if os.path.isfile(’.pythonrc.py’):

execfile(’.pythonrc.py’) Если необходимо использовать инициализационный файл в программе, Вы должны ука зать это явно:

import os filename = os.environ.get(’PYTHONSTARTUP’) if filename and os.path.isfile(filename):

execfile(filename) Глава Неформальное введение в Python В следующих примерах ввод и вывод различаются наличием или отсутствием пригла шения (‘>>> ’ или ‘... ’): для воспроизведения примера Вам следует после появления приглашения набрать весь следующий за приглашением текст. Строки в примере, не на чинающиеся с приглашения, выдаются самим интерпретатором. Обратите внимание, что наличие в строке только вторичного приглашения в примерах означает, что Вы должны ввести пустую строку — таким образом в интерактивном режиме обозначается конец многострочных команд.

Многие примеры в книге, даже если они вводятся в интерактивном режиме, снаб жены комментариями. Комментарии в языке Python начинаются с символа ‘#’ и про должаются до конца строки. Комментарий может начинаться в начале строки или после кода, но не внутри строковых выражений. Символ ‘#’ в строковом выражении является всего лишь символом ‘#’.

Несколько примеров:

# SPAM = 1 # #...,, !

STRING = "#."

3.1 Использование интерпретатора Python в качестве каль кулятора Давайте испробуем несколько простых команд Python. Запустите интерпретатор и до ждитесь появления первичного приглашения ‘>>> ’ (это не должно занять много вре мени.) 3.1.1 Числа Интерпретатор работает как простой калькулятор: Вы можете набрать выражение, и он выведет результат. Синтаксис выражений прост: операторы +, -, * и / работают, как и в большинстве других языков (например, в Pascal и C). Для группирования можно использовать скобки. Например:

24 Глава 3. Неформальное введение в Python >>> 2+ >>> #... 2+ >>> 2+2 #, >>> (50-5*6)/ >>> #... # :

... 7/ >>> 7/- - Подобно С, знак равенства (‘=’) используется для присваивания значения перемен ной. Присвоенное значение при этом не выводится:

>>> width = >>> height = 5* >>> width * height Значение можно присвоить одновременно нескольким переменным:

>>> x = y = z = 0 # x, y z >>> x >>> y >>> z Имеется полная поддержка чисел с плавающей точкой. Операторы со смешанными типами операндов преобразуют целый операнд в число с плавающей точкой:

>>> 4 * 2.5 / 3. 3. >>> 7.0 / 3. Также поддерживаются и комплексные числа. Мнимая часть записывается с суф фиксом ‘j’ или ‘J’. Комплексные числа записываются как ‘(real+imagj)’ или могут быть созданы функцией ‘complex(real, imag)’.

3.1. Использование интерпретатора Python в качестве калькулятора >>> 1j * 1J (-1+0j) >>> 1j * complex(0,1) (-1+0j) >>> 3+1j* (3+3j) >>> (3+1j)* (9+3j) >>> (1+2j)/(1+1j) (1.5+0.5j) Комплексные числа представляются двумя числами с плавающей точкой — дей ствительной и мнимой частью. Чтобы извлечь эти части из комплексного числа z, ис пользуйте z.real and z.imag.

>>> a=1.5+0.5j >>> a.real 1. >>> a.imag 0. Функции преобразования к целому числу и числу с плавающей точкой (int(), long() и float()) не работают для комплексных чисел — такое преобразование неоднозначно. Используйте abs(z) для получения абсолютного значения и z.real для получения вещественной части.

>>> a=1.5+0.5j >>> float(a) Traceback (innermost last):

File "", line 1, in ?

TypeError: can’t convert complex to float;

use e.g.

abs(z) >>> a.real 1. >>> abs(a) 1. В интерактивном режиме последнее выведенное значение сохраняется в перемен ной _. Это позволяет использовать Python в качестве настольного калькулятора, напри мер:

>>> tax = 17.5 / >>> price = 3. >>> price * tax 0. >>> price + _ 26 Глава 3. Неформальное введение в Python 4. >>> print round(_, 2) 4. Пользователь должен обращаться с ней как с переменной, доступной только для чтения.

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

3.1.2 Строки Кроме чисел, Python также может работать со строками (string), которые могут быть записаны различными путями1. Они могут быть заключены в одинарные или двойные кавычки:

>>> ’spam eggs’ ’spam eggs’ >>> ’doesn\’t’ "doesn’t" >>> "doesn’t" "doesn’t" >>> ’"Yes," he said.’ ’"Yes," he said.’ >>> "\"Yes,\" he said."

’"Yes," he said.’ >>> ’"Isn\’t," she said.’ ’"Isn\’t," she said.’ Длинные строковые выражения могут быть разбиты различными способами на несколько строк. Символ новой строки может быть “спрятан” с помощью обратной косой черты (‘\’), например:

hello = ", \n\, C.\n\, \ \n.\n" print hello Результат будет следующим:

,, C.

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

3.1. Использование интерпретатора Python в качестве калькулятора,.

По-другому, текст может быть заключен в утроенные кавычки: """ или ’’’. Кон цы строк не нужно “прятать” при использовании утроенных кавычек, но они будут включены в текст.

print """ Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """ выведет следующее:

Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to Интерпретатор выводит результат строковых операций в том же виде, в котором они могли бы быть набраны: в кавычках, обходя кавычки и другие специальные символы с помощью управляющих последовательностей, начинающихся с обратной косой черты (‘\’). Текст заключается в двойные кавычки, если он не содержит двойные кавычки, во всех остальных случаях, он выводится в одинарных кавычках. Инструкция print, опи санная ниже, может быть использована для вывода текста без кавычек и специальных последовательностей.

Существует также “необрабатываемый” режим ввода строк, задаваемый с помощью буквы ‘r’ или ‘R’ перед кавычками: в этом случае символ обратной косой черты также может быть использован для маскировки символов одинарной и двойной кавычек, если им предшествует нечетное число символов обратной косой черты, однако сам символ обратной косой черты остается частью строки. Даже в таком режиме строка не может заканчиваться нечетным количеством символов обратной косой черты. Необрабатыва емый режим наиболее полезен в тех случаях, когда необходимо вводить значительное количество символов обратной косой черты, например, в регулярных выражениях.

Строки можно объединить (склеить) с помощью оператора + и размножить опера тором *:

>>> word = ’Help’ + ’A’ >>> word ’HelpA’ >>> ’<’ + word*5 + ’>’ ’’ Две строки, записанные друг за другом, автоматически объединяются. Первая стро ка в приведенном примере может быть также записана как ‘word = ’Help’ ’A’’.

28 Глава 3. Неформальное введение в Python Такой метод работает только для строк записанных непосредственно, но не для произ вольных строковых выражений.

>>> ’str’ ’ing’ # ’string’ >>> ’str’.strip() + ’ing’ # ’string’ >>> ’str’.strip() ’ing’ # File "", line ’str’.strip() ’ing’ ^ SyntaxError: invalid syntax Строка — последовательность символов с произвольным доступом, Вы можете получить любой символ строки по его индексу. Подобно C, первый символ имеет индекс 0. Нет отдельного типа для символа, символ — это просто строка единичной длины.

Подобно Icon, подстрока может быть определена с помощью среза — двух индексов, разделенных двоеточием.

>>> word[4] ’A’ >>> word[0:2] ’He’ >>> word[2:4] ’lp’ Строки в языке Python невозможно изменить. Попытка изменить символ в опреде ленной позиции или подстроку вызовет ошибку:

>>> word[0] = ’x’ Traceback (innermost last):

File "", line 1, in ?

TypeError: object doesn’t support item assignment >>> word[:-1] = ’Splat’ Traceback (innermost last):

File "", line 1, in ?

TypeError: object doesn’t support slice assignment Индексы среза имеют полезные значения по умолчанию: опущенный первый индекс считается равным 0, опущенный второй индекс дает такой же результат, как если бы он был равен длине строки.

>>> word[:2] # ’He’ >>> word[2:] #, ’lpA’ 3.1. Использование интерпретатора Python в качестве калькулятора Полезный инвариант операции среза: s[:i] + s[i:] равно s.

>>> word[:2] + word[2:] ’HelpA’ >>> word[:3] + word[3:] ’HelpA’ Срезы с вырожденными индексами обрабатываются изящно: слишком большой ин декс обрабатывается, как если бы он был равен длине строки;

если верхняя граница меньше нижней, то возвращается пустая строка.

>>> word[1:100] ’elpA’ >>> word[10:] ’’ >>> word[2:1] ’’ Индексы могут иметь отрицательные значения, для отсчета с конца:

>>> word[-1] # ’A’ >>> word[-2] # ’p’ >>> word[-2:] # ’pA’ >>> word[:-2] # ’Hel’ Однако -0 обозначает то же самое, что и 0, то есть не будет отсчитываться с конца.

>>> word[-0] # ( -0 0) ’H’ Отрицательные индексы в срезах выходящие за пределы обрабатываются, как если бы они были равны нулю, но не пытайтесь использовать это для простых индексов (с одним элементом):

>>> word[-100:] ’HelpA’ >>> word[-10] # Traceback (innermost last):

File "", line IndexError: string index out of range 30 Глава 3. Неформальное введение в Python Лучший способ запомнить, как определяются индексы в срезе — считать их указы вающими между символами, с номером 0 на левой границе первого символа. А правая граница последнего символа имеет индекс равный длине строки, например:

H e l p A 0 1 2 3 4 -5 -4 -3 -2 - Первая строка чисел показывает позиции в строке, на которые указывают индексы от 0 до 5, вторая — соответствующие отрицательные индексы. Срез от i до j включает в себя все символы между краями, помеченными i и j, соответственно.

Для неотрицательных индексов длина подстроки равняется разности индексов, ес ли они оба не выходят за пределы диапазона, например, длина подстроки word[1:3] равна 2.

Встроенная функция len() возвращает длину строки:

>>> s = ’supercalifragilisticexpialidocious’ >>> len(s) 3.1.3 Строки Unicode Начиная с версии 1.6, в языке Python доступен новый тип данных для хранения текста — строка Unicode. Его можно использовать для работы с текстом, содержа щим одновременно буквы и символы нескольких языков, доступных в Unicode (см.

http://www.unicode.org). Строки Unicode полностью интегрируется с обычными строками, автоматически производя, где это необходимо, преобразование.

Unicode имеет значительное преимущество — предоставляет возможность исполь зовать все символы, используемые в современных и древних текстах. Ранее мы могли использовать только 256 символов из определенной кодовой страницы, что приводило к большим затруднениям, особенно при интернационализации (internationalization, обыч но записывается как i18n — i + 18 символов + n) программного обеспечения. Unicode решает эту проблему, определяя одну кодовую страницу для всех символов.

Создаются строки Unicode настолько же просто, как и обычные строки:

>>> u’Hello World !’ u’Hello World !’ 3.1. Использование интерпретатора Python в качестве калькулятора Маленькая буква ‘u’ перед кавычками указывает, что предполагается создание строки Unicode. Если Вы хотите включить в строку специальные символы, используйте управ ляющие последовательности:

>>> u’Hello\u0020World !’ u’Hello World !’ Управляющая последовательность \u0020 указывает, что необходимо вставить Unicode символ с порядковым номером в шестнадцатеричной системе исчисления 0x0020 (про бел).

Благодаря тому, что первые 256 символов Unicode те же, что и в стандартной ко дировке Latin-1, ввод текста на большинстве языков, используемых в западных странах, сильно упрощается.

Как и для обычных строк, для строк Unicode существует “необрабатываемый” ре жим, задаваемый с помощью буквы ‘r’ или ‘R’ перед кавычками. Управляющими счи таются только последовательности, которые применяются для обозначения символов Unicode, и только если используется нечетное количество символов обратной косой черты перед буквой ‘u’:

>>> ur’Hello\u0020World !’ u’Hello World !’ >>> ur’Hello\\u0020World !’ u’Hello\\\\u0020World !’ Кроме описанного выше метода, Python предоставляет возможность создать строку Unicode на основе строки в известной кодировке. Встроенная функция unicode() может работать с Latin-1, ASCII, UTF-8, UTF-16, с русскими кодировками ISO-8859 5, KOI8-R, CP1251, CP866 и Mac-cyrillic, и многими другими. Python по умолчанию использует кодировку ASCII2, например, при выводе на экран инструкцией print и записи в файл. Если у Вас есть данные в определенной кодировке, для получения строки Unicode используйте встроенную функцию unicode(), указав кодировку в качестве второго аргумента:

>>> s = unicode("", "KOI8-R") >>> s u’\u041F\u0440\u0438\u0432\u0435\u0442’ Если строка Unicode содержит символы с кодом больше 127, преобразование в ASCII не возможно:

>>> str(s) Traceback (most recent call last):

ASCII является общей частью для подавляющего большинства кодировок. Вы можете изменить коди ровку по умолчанию с помощью функции sys.set_string_encoding(). Однако лучше все же указы вать ее явно.

32 Глава 3. Неформальное введение в Python File "", line 1, in ?

UnicodeError: ASCII encoding error: ordinal not in range(128) Метод encode() позволяет преобразовывать строки Unicode в обычные строки, содер жащие текст в указанной кодировке:

>>> s.encode("KOI8-R") ’\360\322\311\327\305\324’ >>> s.encode("UTF-8") ’\320\237\321\200\320\270\320\262\320\265\321\202’ 3.1.4 Списки В Python имеется несколько типов данных, используемых для группирования вместе нескольких значений. Самым гибким является список (list), который может быть записан в виде списка значений (элементов), разделенных запятыми, заключенного в квадратные скобки. Совсем не обязательно, чтобы элементы списка были одного типа.

>>> a = [’spam’, ’eggs’, 100, 1234] >>> a [’spam’, ’eggs’, 100, 1234] Как и для строк, для списков нумерация индексов начинается с нуля. Для списка можно получить срез, объединить несколько списков и так далее:

>>> a[0] ’spam’ >>> a[3] >>> a[-2] >>> a[1:-1] [’eggs’, 100] >>> a[:2] + [’bacon’, 2*2] [’spam’, ’eggs’, ’bacon’, 4] >>> 3*a[:3] + [’Boe!’] [’spam’, ’eggs’, 100, ’spam’, ’eggs’, 100, ’spam’, ’eggs’, 100, ’Boe!’] В отличие от строк, которые неизменяемы (immutable), существует возможность изменения отдельных элементов списка:

>>> a [’spam’, ’eggs’, 100, 1234] 3.1. Использование интерпретатора Python в качестве калькулятора >>> a[2] = a[2] + >>> a [’spam’, ’eggs’, 123, 1234] Присваивание срезу также возможно, и это может привести к изменению размера списка:

>>> # :

... a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # :

... a[0:2] = [] >>> a [123, 1234] >>> # :

... a[1:1] = [’bletch’, ’xyzzy’] >>> a [123, ’bletch’, ’xyzzy’, 1234] >>> # :

>>> a[:0] = a >>> a [123, ’bletch’, ’xyzzy’, 1234, 123, ’bletch’, ’xyzzy’, 1234] Встроенная функция len() также применима и к спискам:

>>> len(a) Списки могут быть вложенными (списки, содержащие другие списки), например:

>>> q = [2, 3] >>> p = [1, q, 4] >>> len(p) >>> p[1] [2, 3] >>> p[1][0] >>> p[1].append(’xtra’) >>> p [1, [2, 3, ’xtra’], 4] >>> q [2, 3, ’xtra’] Как Вы уже, наверное, догадались, метод append() добавляет элемент в конец списка.

Заметьте, что p[1] и q на самом деле ссылаются на один и тот же объект!

34 Глава 3. Неформальное введение в Python 3.2 Первые шаги к программированию Конечно, мы можем использовать Python для более сложных задач, чем “два плюс два”.

Например, можно вывести начало ряда Фибоначчи:

>>> # :

... #... #... a, b = 0, >>> while b < 10:

... print b... a, b = b, a+b...

Этот пример знакомит с несколькими новыми особенностями.

• Первая строка содержит множественное присваивание (multiple assignment): пе ременным a и b одновременно присваиваются новые значения 0 и 1. В последней строке оно используется снова, демонстрируя, что выражения в правой части вы числяются до того как будет осуществлено присваивание. Выражения в правой части вычисляются слева направо.

• Цикл while выполняется пока условие (здесь: b < 10) является истинным. В Python, как и в С, любое ненулевое значение является истиной, ноль — ложь. В качестве условия может служить также строка, список — на самом деле любая последовательность. Последовательность с ненулевой длиной является истиной, пустая — ложью. Проверка, использованная в примере, является простым сравне нием. Стандартные операторы сравнения записываются так же, как в С: <, >, ==, <= (меньше или равно), >= (больше или равно) и != (не равно).

• Тело цикла записано с отступом: отступы используются в языке Python для запи си группирующих инструкций. Интерпретатор (пока) не предоставляет разумных средств редактирования вводимых строк, поэтому Вам необходимо нажимать кла вишу табуляции или пробела для каждой строки с отступом. На практике Вы будете готовить более сложный ввод для Python с помощью текстового редактора, большинство из которых позволяют делать сдвиг автоматически. Когда составная инструкция вводится интерактивно, за ним должна следовать пуста строка, как признак завершения (поскольку синтаксический анализатор не может угадать, ко гда Вы ввели последнюю строку). Заметим, что сдвиг строк внутри блока должен быть одинаковым.

3.2. Первые шаги к программированию • Инструкция print выводит переданные ей значения. В отличие от простого вы вода значений интерпретатором в интерактивном режиме (которым мы пользова лись ранее в примерах использования интерпретатора в качестве калькулятора), инструкция print выводит строки без кавычек и между элементами вставляет пробел, так что Вы можете удобно форматировать вывод:

>>> i = 256* >>> print ’ i ’, i i Завершающая запятая позволяет после вывода значения вставлять пробел вместо перехода на новую строку:

>>> a, b = 0, >>> while b < 1000:

... print b,... a, b = b, a+b...

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 Обратите внимание, что интерпретатор переходит на новую строку перед выводом следующего приглашения, даже если последняя выведенная строка не завершается переходом на новую строку.

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

4.1 Инструкция if Пожалуй, наиболее известной является инструкция if:

>>> x = int(raw_input(",, : ")) >>> if x < 0:

... x =... print ’, ’... elif x == 0:

... print ’’... elif x == 1:

... print ’’... else:

... print ’’...

Ветвь elif может, как совсем отсутствовать, так и присутствовать несколько раз;

на личие ветви else необязательно. Ключевое слово elif является короткой формой для else if и позволяет избежать чрезмерных отступов. Последовательность if...

elif... elif... эквивалентна инструкциям switch и case в других языках.

4.2 Инструкция for Инструкция for в языке Python немного отличается от того, что используется в таких языках как C или Pascal. Вместо того, чтобы всегда перебирать числа арифметической прогрессии (как в Pascal), или предоставлять пользователю полную свободу выбора итератора и условия выхода из цикла (как в С), перебирает элементы произвольной С формальной точки зрения это не совсем так: в языке Python под последовательностью всегда подра зумевается последовательность с произвольным доступом;

средства для работы с последовательностями 4.3. Функции range() и xrange() последовательности (например, списка или строки) в порядке их следования:

>>> # :

... a = [’’, ’’, ’’] >>> for x in a:

... print x, len(x)...

Небезопасно изменять в цикле итерируемую последовательность (такое возможно только для последовательностей, допускающих изменение, например, списков). Если Вы собираетесь вносить изменения в список, элементы которого перебираете, например, продублировать избранные элементы, следует перебирать элементы копии исходного списка. Запись в виде среза делает это особенно удобным:

>>> for x in a[:]: # ()... if len(x) > 4: a.insert(0, x)...

>>> for x in a:

... print x,...

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

4.3 Функции range() и xrange() Если Вам необходимо перебирать последовательность чисел, то пригодится встроенная функция range(). Она создает список, содержащий арифметическую прогрессию:

>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Указанная верхняя граница никогда не входит в созданную последовательность.

range(10) создает список из 10 значений, точно соответствующих допустимым ин дексам для элементов последовательности, имеющей длину 10. Можно указать другую нижнюю границу или другое приращение (шаг), в том числе и отрицательное:

(в том числе и инструкция for) требует возможности получить произвольный элемент по индексу.

38 Глава 4. Средства управления логикой >>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70] Для того, чтобы перебрать индексы последовательности, используйте совместно range() и len():

>>> a = [’’, ’’, ’’, ’’, ’’] >>> for i in range(len(a)):

... print i, a[i]...

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

>>> l=range(10000000) Traceback (innermost last):

File "", line 1, in ?

MemoryError Действительно, если мы не собираемся изменять список, достаточно создать псевдоспи сок — объект, для которого мы можем получить значения “элементов”, но не можем изменить их или порядок их следования. Для этих целей в языке Python предусмотрена функция xrange():

>>> xrange(5, 10) (5, 6, 7, 8, 9) >>> xrange(0, 10, 3) (0, 3, 6, 9) >>> xrange(-10, -100, -30) (-10, -40, -70) >>> a = [’’, ’’, ’’, ’’, ’’] >>> for i in xrange(len(a)):

... print i, a[i]...

4.4. Инструкции break и continue, ветвь else в циклах 4.4 Инструкции break и continue, ветвь else в циклах Инструкция break, как и в C, выходит из самого внутреннего вложенного цикла for или while. Инструкция continue, также позаимствованная из C, продолжает выпол нение цикла со следующей итерации.

Циклы могут иметь ветвь else, которая выполняется при “нормальном” выхо де (исчерпание последовательности в цикле for, неудовлетворение условия в цикле while), без прерывания инструкцией break. Продемонстрируем ее использование на примере поиска простых чисел:

>>> for n in xrange(2, 10):

... for x in xrange(2, n):

... if n % x == 0:

... print n, ’=’, x, ’*’, n/x... break... else:

... print n, ’- ’...

2 - 3 - 4 = 2 * 5 - 6 = 2 * 7 - 8 = 2 * 9 = 3 * 4.5 Инструкция pass Инструкция pass ничего не делает и может быть использована там, где инструкция требуется синтаксисом языка, однако действий никаких выполнять не требуется:

>>> while 1:

... pass #...

40 Глава 4. Средства управления логикой 4.6 Определение функций Мы можем создать функцию, которая будет выводить последовательность чисел Фибо наччи с произвольной верхней границей:

>>> def fib(n):

... ’’’,... n’’’... a, b = 0,... while b < n:

... print b,... a, b = b, a+b...

>>> #... fib(2000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 Ключевое слово def представляет определение функции. После него должно сле довать имя функции и, в скобках, список формальных параметров. Инструкции, образу ющие тело функции, записываются с отступом, начиная со следующей строки. Первой инструкцией тела функции может быть строка документации (см. раздел 4.7.5). Су ществуют средства для автоматического создания документации, а также средства, поз воляющие пользователю просматривать строки документации в интерактивном режиме.

Включение строк документации в код является хорошей традицией.

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

Аргументы функции в момент вызова помещаются в локальную таблицу имен вы зываемой функции. Таким образом, аргументы передаются по значению (где значение всегда является ссылкой на объект, а не его значением)2. В случае вызова функции другой функцией, также создается новая локальная таблица имен для этого вызова.

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

>>> fib На самом деле, правильнее было бы сказать, что аргументы передаются по ссылке на объект: если передается объект, допускающий изменения, то изменения (например, добавление элементов в список) будут видны в том месте, откуда функция была вызвана.

4.6. Определение функций >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 Вы можете возразить, что fib является процедурой, а не функцией. В языке Python, как и в C, процедура — всего лишь функция, которая не возвращает никакого значения. Строго говоря, процедуры все же возвращают значение, которое, скорее, не представляет большого интереса. Это значение — None (встроенное имя). Значение None обычно не выводится интерпретатором, но Вы можете его увидеть, если действи тельно хотите этого:

>>> print fib(0) None Довольно просто написать функцию, которая возвращает список чисел ряда Фибо наччи, вместо того, чтобы выводить их:

>>> def fib2(n):

... ’’’,..., n’’’... result = []... a, b = 0,... while b < n:

... result.append(b)... a, b = b, a+b... return result...

>>> #... f100 = fib2(100) >>> #... f [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] Этот пример, как обычно, демонстрирует несколько новых особенностей языка Python:

• Инструкция return выходит из функции и возвращает значение. Без аргументов return используется для выхода из середины процедуры (иначе выход происходит при достижении конца процедуры), в этом случае возвращается значение None.

• Инструкция result.append(b) вызывает метод объекта-списка result. Ме тод — это функция, “принадлежащая” объекту, вызывается как obj.methodname, где obj — объект (или выражение его определяющее) и methodname — имя ме тода, определенного для данного типа объектов. Различные типы имеют различные наборы методов. Методы различных типов могут иметь одинаковые имена, не при водя к неопределенности. (Вы можете определить собственные типы объектов — 42 Глава 4. Средства управления логикой классы — и методы работы с ними.) Метод append(), используемый в примере, определен для объектов-списков. Он добавляет элемент в конец списка. В приве денном примере его использование эквивалентно записи ‘result = result + [b]’, но более эффективно.

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

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

def ask_ok(prompt, retries=4, complaint=’, !’):

while 1:

ok = raw_input(prompt) if ok in (’’, ’’): return if ok in (’’, ’’, ’’): return retries = retries - if retries < 0:

raise IOError( ’ ’) print complaint Эта функция может быть вызвана так: ‘ask_ok(’ ?’)’, или так: ‘ask_ok(’ ?’, 2)’.

Значения по умолчанию вычисляются в месте определения функции в области видимости определения, так что i = def f(arg = i): print arg i = f() выведет 5.

Важное замечание: значение по умолчанию вычисляется только один раз. Это отражается в том случае, когда аргумент со значением по умолчанию является объектом, 4.7. Дополнительные возможности в определении функций допускающим изменения, таким как список или словарь. Например, следующая функция накапливает передаваемые аргументы (то есть переменная l является статической)3:

def f(a, l = []):

l.append(a) return l print f(1) print f(2) print f(3) Результат выполнения будет следующий:

[1] [1, 2] [1, 2, 3] Если Вы не хотите, чтобы аргумент по умолчанию совместно использовался при последующих вызовах, можете немного изменить функцию:

def f(a, l = None):

if l is None:

l = [] l.append(a) return l 4.7.2 Произвольный набор аргументов Наконец, не так часто используемый вариант — определить функцию таким образом, чтобы ее можно было вызвать с произвольным числом аргументов. В этом случае аргу менты будут переданы в виде кортежа4. Перед переменным числом аргументов может присутствовать произвольное число обычных аргументов:

def fprintf(file, format, *args):

file.write(format % args) 4.7.3 Именованные аргументы Функция может быть вызвана с использованием именованных аргументов (keyword arguments) в виде ‘keyword = value’. Например, функция ask_ok() (раздел 4.7.1) может быть вызвана следующими способами:

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

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

44 Глава 4. Средства управления логикой ask_ok(’ ?’) ask_ok(retries = 2, prompt = ’ ?’) ask_ok(’?’, complaint = ’, -!’) ask_ok(’ ?’, 100, ’ - ?’) Однако следующие вызовы ошибочны:

# ask_ok() # ask_ok(prompt = ’ ?’, 2) # ask_ok(’?’, prompt = ’/’) # ask_ok(actor = ’’) В общем, в списке аргументов именованные аргументы должны следовать после по зиционных. Не имеет значение, имеет неименованный аргумент значение по умолчанию или нет. Никакой аргумент не может быть передан более одного раза:

>>> def function(a):

... pass...

>>> function(0, a=0) Traceback (innermost last):

File "", line 1, in ?

TypeError: keyword parameter redefined Если в определении функции присутствует формальный параметр в виде **name, то его значением становится словарь, содержащий все именованные аргументы, чьи имена не соответствуют формальным параметрам. Такой способ можно комбинировать с формой *name, позволяющей получить кортеж (tuple), содержащий позиционные ар гументы, не входящие в список формальных параметров. (Запись **name должна сле довать после записи *name.) Например, определим функцию:

def example(formal, *arguments, **keywords):

print " :", formal print ’-’* for arg in arguments: print arg print ’-’* for kw in keywords.keys():

print kw, ’:’, keywords[kw] 4.7. Дополнительные возможности в определении функций Ее можно вызвать следующим образом:

example(1000000, ’ ’, ’ ’, language = ’Python’, author = ’Guido van Rossum’) Вывод будет таким:

: --------------------------------------- --------------------------------------- language: Python author: Guido van Rossum 4.7.4 Короткая форма Python содержит несколько популярных особенностей, характерных для языков функци онального программирования. С помощью ключевого слова lambda Вы можете создать простую функцию без имени. Например, функция, возвращающая сумму двух своих ар гументов, может быть записана как ‘lambda a, b: a+b’. Короткая форма может быть использована везде, где требуется объект-функция. Ее синтаксис ограничен одним вы ражением. Как и в обычных определениях функций, при записи в короткой форме Вы не можете ссылаться на переменные, находящиеся в области видимости, которая содержит определение этой функции. Однако это ограничение можно обойти, используя значения аргументов по умолчанию:

>>> def make_incrementor(n):

... return lambda x, incr=n: x+incr...

>>> f = make_incrementor(42) >>> f(0) >>> f(1) 4.7.5 Строки документации Строки документации обычно состоят из одной строки с кратким изложением назна чения (или использования) объекта и более подробного описания, разделенных пустой 46 Глава 4. Средства управления логикой строкой. Первая строка часто используется интегрированными средами разработки (на пример, IDLE) в качестве подсказки при использовании объекта. Большинство встроен ных объектов и объектов, определенных в стандартной библиотеке, снабжены строками документации — используйте их в качестве примеров оформления. Например:

>>> print map.doc map(function, sequence[, sequence,...]) -> list Return a list of the results of applying the function to the items of the argument sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If the function is None, return a list of the items of the sequence (or a list of tuples if more than one sequence).

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

4.7.6 Вызов функций Помимо описанного (func(arg... )), язык Python предоставляет еще несколько спо собов вызова функций. Начиная с версии 1.6, Вы можете указать кортеж позиционных и словарь именованных аргументов, например:

args = (’ ’, ’ ’) kwds = {’language’: ’Python’, ’author’: ’Guido van Rossum’) example(1000000, *args, **kwds) Такой же эффект можно получить используя встроенную функцию apply():

apply(example, (1000000,)+args, kwds) С помощью средств функционального программирования Вы можете применить функцию к элементам последовательности (см. раздел 5.2).

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

5.1 Подробнее о списках Ранее мы уже говорили, что метод append() позволяет добавить элемент в конец списка:

>>> a = [66.6, 333, 333, 1, 1234.5] >>> a.append(333) >>> a [66.6, 333, 333, 1, 1234.5, 333] Однако иногда необходимо вставить элемент в начало или другую позицию списка. Это позволяет сделать метод insert — Вы указываете индекс элемента, перед которым новый элемент будет добавлен:

>>> a.insert(2, -1) [66.6, 333, -1, 333, 1, 1234.5, 333] Кроме того, для списков определены методы, позволяющие анализировать его со держимое: найти, в каком положении находится (первый) элемент с определенным зна чением (метод index), или подсчитать количество таких элементов (метод count):

>>> a.index(333) >>> print a.count(333), a.count(66.6), a.count(’x’) 3 1 Метод remove() позволяет удалить из списка (первый) элемент, имеющий заданное значение:

>>> a.remove(333) >>> a [66.6, -1, 333, 1, 1234.5, 333] 48 Глава 5. Структуры данных Элементы списка можно отсортировать (метод sort()) и изменить порядок сле дования элементов на противоположный (метод reverse()):

>>> a.sort() # >>> a [-1, 1, 66.6, 333, 333, 1234.5] >>> a.reverse() >>> a [1234.5, 333, 333, 66.6, 1, -1] Более подробно эти и другие операции над списками описаны в разделе 11.2.6.

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

5.1.1 Стеки Методы, определенные для списков, позволяют использовать список в качестве стека, где последний добавленный элемент извлекается первым (LIFO, “last-in, first-out”). Для добавления элемента в стек, используйте метод append(), для извлечения элемента с вершины стека — метод pop() без явного указания индекса:

>>> stack = [3, 4, 5] >>> stack.append(6) >>> stack.append(7) >>> stack [3, 4, 5, 6, 7] >>> stack.pop() >>> stack [3, 4, 5, 6] >>> stack.pop() >>> stack.pop() >>> stack [3, 4] 5.1.2 Очереди Еще одно применение списков — очереди, где элементы извлекаются в том же порядке, в котором они добавлялись (FIFO, “first-in, first-out”). Для добавления элемента в стек, используйте метод append(), для извлечения “очередного” элемента — метод pop() с индексом 0:

5.2. Средства функционального программирования >>> queue = ["Eric", "John", "Michael"] >>> queue.append("Terry") # Terry >>> queue.append("Graham") # Graham >>> queue.pop(0) ’Eric’ >>> queue.pop(0) ’John’ >>> queue [’Michael’, ’Terry’, ’Graham’] 5.2 Средства функционального программирования Существуют три встроенные функции, которые могут быть полезны при работе с после довательностями: filter(), map(), zip() и reduce().

filter(function, sequence) возвращает последовательность (по возможно сти того же типа, что и sequence), состоящую из тех элементов последовательности sequence, для которых function(item) является истиной. Например, выделим про стые числа из списка:

>>> def f(x):

... for y in xrange(2, x):

... if x%y==0: return... return...

>>> filter(f, xrange(2, 40)) [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37] map(function, sequence [... ]) возвращает список значений, полученных применением функции function к элементам одной или нескольких последовательно стей. Например, создадим список кубов натуральных чисел:

>>> def cube(x): return x*x*x...

>>> map(cube, xrange(1, 11)) [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000] Функция function должна воспринимать столько аргументов, сколько последо вательностей передается. Она вызывается с соответствующими элементами из каждой последовательности или None, если какая-нибудь последовательность оказалась коро че других. Если function равно None, то используется функция, возвращающая свои аргументы.

Учитывая эти две особенности, мы видим, что ‘map(None, list1, list2)’ является удобным способом превращения пары списков в список пар:

50 Глава 5. Структуры данных >>> seq = xrange(8) >>> def square(x): return x*x...

>>> map(None, seq, map(square, seq)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)] Таким образом Вы можете перебирать элементы одновременно несколько последова тельностей одинаковой длины:

>>> seq1 = [’cat’, ’mouse’, ’bird’] >>> seq2 = [’’, ’’, ’’] >>> for x, y in map(None, seq1, seq2):

... print x, y...

cat mouse bird Как мы уже говорили, если какая-либо последовательность оказывается короче дру гих, функция map() дополняет ее элементами, равными None. Такое поведение не все гда желательно. Поэтому в версии 2.0 была добавлена функция zip(). zip(sequence [... ]) возвращает список кортежей, каждый из которых состоит из соответствую щих элементов аргументов-последовательностей. При этом длина полученной последо вательности будет равна длине самой короткой последовательности среди аргументов.

Например:

>>> a = (1, 2, 3, 4) >>> b = (5, 6, 7, 8) >>> c = (9, 10, 11) >>> d = (12, 13) >>> zip(a, b) [(1, 5), (2, 6), (3, 7), (4, 8)] >>> zip(a, d) [(1, 12), (2, 13)] >>> zip(a, b, c, d) [(1, 5, 9, 12), (2, 6, 10, 13)] Если последовательности имеют одинаковую длину, поведение функции zip() полностью аналогично поведению map() с None в качестве первого аргумента. Кроме того, в этом случае действие функций zip() и map() обратимо:

>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> x = zip(a, b) >>> y = zip(*x) # apply(zip, x) 5.3. Дополнительные возможности при конструировании списков >>> z = zip(*y) # apply(zip, y) >>> x [(1, 4), (2, 5), (3, 6)] >>> y [(1, 2, 3), (4, 5, 6)] >>> z [(1, 4), (2, 5), (3, 6)] >>> x == z reduce(function, sequence [, initial]) возвращает значение, полученное путем последовательного применения бинарной функции function сначала к первым двум элементам последовательности sequence, затем к результату и следующему эле менту и т. д. Например, вычислим сумму арифметической последовательности:

>>> def add(x, y): return x+y...

>>> reduce(add, xrange(1, 11)) Если последовательность содержит единственный элемент, возвращается его зна чение, если же последовательность пуста, то генерируется исключение TypeError.

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

>>> def sum(seq):

... def add(x,y): return x+y... return reduce(add, seq, 0)...

>>> sum(xrange(1, 11)) >>> sum([]) 5.3 Дополнительные возможности при конструировании списков Начиная с версии 2.0, языка Python, существуют дополнительные возможности констру ирования списков, не прибегая к средствам функционального программирования. Такие определения списков записываются с использованием в квадратных скобках выражения и следующих за ним блоков for:

52 Глава 5. Структуры данных >>> freshfruit = [’ banana’,... ’ loganberry ’,... ’passion fruit ’] >>> [weapon.strip() for weapon in freshfruit] [’banana’, ’loganberry’, ’passion fruit’] >>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18] >>> [{x: x**2} for x in vec] [{2: 4}, {4: 16}, {6: 36}] >>> [[x,x**2] for x in vec] [[2, 4], [4, 16], [6, 36]] Элементы можно фильтровать, указав условие, записываемое с помощью ключевого слова if:

>>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x < 2] [] Выражение, дающее кортеж, обязательно должно быть записано в скобках:

>>> [x, x**2 for x in vec] File "", line [x, x**2 for x in vec] ^ SyntaxError: invalid syntax >>> [(x, x**2) for x in vec] [(2, 4), (4, 16), (6, 36)] Если в конструкторе указано несколько блоков for, элементы второй последователь ности перебираются для каждого элемента первой и т. д., то есть перебираются все комбинации:

>>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] 5.4 Инструкция del Существует способ удалить не только элемент по его значению, но и элемент с опреде ленным индексом, элементы с индексами в определенном диапазоне (ранее мы произво 5.5. Кортежи дили эту операцию путем присваивания пустого списка срезу): инструкция del:

>>> a [-1, 1, 66.6, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.6, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.6, 1234.5] Инструкция del может быть также использована для удаления переменных:

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

5.5 Кортежи Списки и строки имеют много общего, например, для них можно получить элемент по индексу или применить операцию среза. Это два примера последовательностей. Еще одним встроенным типом последовательностей является кортеж (tuple).

Кортеж состоит из набора значений, разделенных запятой, например:

>>> t = 12345, 54321, ’hello!’ >>> t[0] >>> t (12345, 54321, ’hello!’) >>> # :

... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, ’hello!’), (1, 2, 3, 4, 5)) Как Вы заметили, при выводе кортежи всегда заключаются в круглые скобки, для того, чтобы вложенные кортежи воспринимались корректно. Вводить их можно как в скобках, так и без них, хотя в некоторых случаях скобки необходимы (если кортеж является частью более сложного выражения).

Кортежи имеют множество применений: пара координат (x, y), запись в базе дан ных и т. д. Кортежи, как и строки, не допускают изменений: нельзя присвоить значение 54 Глава 5. Структуры данных элементу кортежа (тем не менее, Вы можете имитировать такую операцию с помощью срезов и последующего объединения).

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

>>> empty = () >>> #... singleton = ’hello’, >>> len(empty) >>> empty () >>> len(singleton) >>> singleton (’hello’,) Инструкция t = 12345, 54321, ’hello!’ — пример упаковки в кортеж:

значения 12345, 54321 и ’hello!’ упаковываются вместе в один кортеж. Также возможна обратная операция — распаковки кортежа:

>>> x, y, z = t Распаковка кортежа требует, чтобы слева стояло столько переменных, сколько эле ментов в кортеже. Следует заметить, что множественное присваивание является всего лишь комбинацией упаковки и распаковки кортежа. Иногда может оказаться полезной распаковка списка:

>>> a = [’spam’, ’eggs’, 100, 1234] >>> a1, a2, a3, a4 = a Как мы уже говорили, кортежи, как и строки, не допускают изменений. Однако, в отличие от строк, кортежи могут содержать объекты, которые можно изменить с помощью методов:

>>> t = 1, [’foo’, ’bar’] >>> t (1, [’foo’, ’bar’]) >>> t[1] = [] # Traceback (innermost last):

File "", line 1, in ?

TypeError: object doesn’t support item assignment 5.6. Словари >>> t[1].append(’baz’) # >>> t (1, [’foo’, ’bar’, ’baz’]) 5.6 Словари Еще один встроенный в Python тип данных — словарь (dictionary) — часто называют ассоциативным массивом. В отличие от последовательностей, индексируемых диапазо ном чисел, доступ к элементам словаря производится по ключу, который может быть любого типа, не допускающего изменений1 — строки и числа всегда могут быть ключа ми. Кортежи могут использоваться в качестве ключа, если они содержат строки, числа и кортежи, удовлетворяющие этому правилу. Нельзя использовать списки, так как их можно изменить (не создавая нового объекта-списка) с помощью, например, метода append().

Лучше всего представлять словарь как неупорядоченное множество пар ключ: зна чение, с требованием уникальности ключей в пределах одного словаря. Пара фигурных скобок {} создает пустой словарь. Помещая список пар key: value, разделенных за пятыми, в фигурные скобки, Вы задаете начальное содержимое словаря. В таком же виде записывается словарь при выводе.

Основные операции над словарем — сохранение с заданным ключом и извлечение по нему значения. Также можно удалить пару key: value с помощью инструкции del.

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

Метод keys() для словаря возвращает список всех используемых ключей в про извольном порядке (если Вы хотите, чтобы список был отсортирован, просто примените к нему метод sort()). Чтобы определить, используется ли определенный ключ — ис пользуйте метод has_key().

Приведем простой пример использования словаря в качестве телефонного справоч ника:

>>> tel = {’jack’: 4098, ’sape’: 4139} >>> tel[’guido’] = >>> tel {’sape’: 4139, ’guido’: 4127, ’jack’: 4098} >>> tel[’jack’] >>> del tel[’sape’] >>> tel[’irv’] = На самом деле, в качестве ключа может служить любой объект (в том числе допускающий изменения), для которого определена функция hash(). Правило относится, скорее, к стандартным типам данных языка.

56 Глава 5. Структуры данных >>> tel {’guido’: 4127, ’irv’: 4127, ’jack’: 4098} >>> tel.keys() [’guido’, ’irv’, ’jack’] >>> tel.has_key(’guido’) 5.7 Подробнее об условиях Помимо описанных ранее операторов сравнения, существует еще несколько условных операторов.

Операторы in и not in проверяют, есть указанное значение в последовательно сти. Операторы is и is not определяют, ссылаются ли две переменные на один и тот же объект. Все приведенные здесь операторы имеют одинаковый приоритет, который ниже, чем у арифметических операторов.

Логические выражения могут быть сцеплены: например, ‘a < b == c’ проверяет, меньше ли a чем b и равны ли b и c.

Логические выражения можно группировать с помощью логических операторов and и or, а также результат можно инвертировать оператором not. Все логические операторы имеют меньший приоритет, чем операторы сравнения. Среди логических опе раторов, not имеет наибольший приоритет и or — наименьший. Таким образом, ‘A or not B and C’ эквивалентно ‘A or ((not B) or C)’. Безусловно, можно использо вать скобки для определения порядка вычисления.

Аргументы логических операторов and и or вычисляются справа налево до тех пор, пока результат не будет определен. Например, если выражения A и C истинны, но B ложно, в ‘A and B and C’ выражение C вычисляться не будет. Вообще говоря, возвращаемое значение операторов and и or является не логическим, а равно значению последнего вычисленного аргумента.

Можно присвоить результат сравнения или логического выражения переменной:

>>> string1, string2, string3 = \... ’’, ’Trondheim’, ’Hammer Dance’ >>> non_null = string1 or string2 or string >>> non_null ’Trondheim’ Обратите внимание, что, в отличие от C, присваивание не может находиться вну три выражения. Такое ограничение позволяет избежать ошибок, типичных для программ на C: использование = вместо ==.

5.8. Сравнение последовательностей 5.8 Сравнение последовательностей Объекты-последовательности можно сравнивать с другими объектами того же типа.

Сравнение производится лексикографически: сначала сравниваются первые элементы последовательностей, и, если они отличаются, то результат их сравнения определяет результат;

если они равны, сравниваются следующие элементы и т. д., пока не бу дет определен результат или одна из последовательностей не будет исчерпана. Если два элемента сами являются последовательностями одного типа, то лексикографиче ское сравнение выполняется рекурсивно. Если все элементы двух последовательностей в результате сравнения оказываются равными, то последовательности считаются равны ми. Если одна из последовательностей является началом другой, то меньшей считается последовательность с меньшим количеством элементов. Лексикографический порядок строк определяется порядком следования ASCII символов. Приведем несколько приме ров сравнения последовательностей одинакового типа:

(1, 2, 3) < (1, 2, 4) [1, 2, 3] < [1, 2, 4] ’ABC’ < ’C’ < ’Pascal’ < ’Python’ (1, 2, 3, 4) < (1, 2, 4) (1, 2) < (1, 2, -1) (1, 2, 3) == (1.0, 2.0, 3.0) (1, 2, (’aa’, ’ab’)) < (1, 2, (’abc’, ’a’), 4) Заметим, что сравнение объектов различного типа допустимо. Результат будет вполне определенным, однако не следует на него полагаться — правила сравнения объ ектов различного типа могут измениться в следующих версиях языка. Числа сравнива ются в соответствии с их значениями, так 0 равен 0.0, и т. д.

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

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

6.1 Создание и использование модулей Модуль — файл, содержащий определения и другие инструкции языка Python. Имя файла образуется путем добавления к имени модуля суффикса (расширения) ‘.py’. В пределах модуля, его имя доступно в глобальной переменной name. Например, ис пользуя Ваш любимый текстовый редактор, создайте в текущем каталоге файл с именем ‘fibo.py’ следующего содержания:

’’’\ ’’’ def fib(n):

’’’, n’’’ a, b = 0, while b < n:

print b, a, b = b, a+b def fib2(n):

’’’,, n’’’ 6.1. Создание и использование модулей result = [] a, b = 0, while b < n:

result.append(b) a, b = b, a+b return result Теперь запустите интерпретатор и импортируйте только что созданный модуль:

>>> import fibo Эта инструкция не вводит имена функций, определенных в fibo прямо в текущее про странство имен, она только вводит имя модуля fibo. Используя имя модуля, Вы можете получить доступ к функциям:

>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.name ’fibo’ Если Вы собираетесь использовать функцию часто, можете присвоить ее локальной переменной:

>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 Модуль может содержать любые инструкции, предназначенные для его инициа лизации, а не только определения функций. Они выполняются, только когда модуль импортируется первый раз.

Каждый модуль имеет собственное пространство имен, являющееся глобальной об ластью видимости для всех определенных в нем функций. Таким образом, автор модуля может использовать глобальные переменные, не беспокоясь о возможных конфликтах с глобальными переменными пользователя. С другой стороны, если Вы знаете, что делаете, Вы можете получить доступ к глобальным переменным модуля точно так же, как и к его функциям (на самом деле, функции тоже являются переменными), modname.itemname.

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

Другой вариант инструкции import импортирует имена из модуля непосредствен но в текущее пространство имен:

60 Глава 6. Модули >>> from fibo import fib, fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 В этом случае имя модуля не будет представлено в текущей области видимости (в приведенном примере, имя fibo не определено).

Еще один вариант инструкции import позволяет импортировать все имена, опре деленные в модуле, кроме имен, начинающихся с символа подчеркивания (‘_’):

>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 Часто возникает необходимость импортировать модуль или объект модуля, исполь зуя для него локальное имя, отличное от исходного. Например, следующий код позволя ет заменить имя string на _string (которое не будет импортироваться инструкцией ‘from my_module import *’) при написании модуля:

import string _string = string del string Еще один пример показывает, как можно избежать конфликта имени, определенного в модуле, со встроенным именем:

import anydbm dbopen = anydbm.open Начиная с версии 2.0, подобные операции можно произвести гораздо проще (и безопас нее) благодаря расширению синтаксиса инструкции import:

import string as _string from anydbm import open as dbopen Следует заметить, что as не является зарезервированным словом, и Вы можете по прежнему определять переменные с таким именем.

Если имя модуля, который необходимо импортировать, становится известным толь ко во время выполнения программы, Вы можете воспользоваться инструкцией exec (‘exec ’import ’ + module_name’) или встроенной функцией import() (см.

раздел 12).

6.2. Поиск модулей 6.2 Поиск модулей Когда импортируется модуль, например spam, интерпретатор ищет файл с именем ‘spam.py’ в текущем каталоге, затем в каталогах, указанных в переменной окружения PYTHONPATH, затем в зависящих от платформы путях по умолчанию.

Каталоги, в которых осуществляется поиск, хранятся в переменной sys.path.

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

6.3 “Компилированные” файлы Для ускорения запуска программ, использующих большое количество модулей, если уже существует файл с именем ‘spam.pyc’ в том же каталоге, где найден ‘spam.py’, считается, что он содержит “байт-компилированный” модуль spam. Если такого файла нет, то он создается, и время последнего изменения ‘spam.py’ записывается в созданном ‘spam.pyc’ (при последующем использовании, ‘.pyc’-файл игнорируется, если исходный ‘.py’-файл был изменен).

Обычно Вам не надо ничего делать для создания ‘spam.pyc’. Как только ‘spam.py’ успешно откомпилирован, интерпретатор пытается записать компилированную версию в ‘spam.pyc’. Если интерпретатору по каким-либо причинам это не удается (например, недостаточно пользовательских полномочий), ошибки не возникает. Если же файл за писан не полностью, далее он распознается как неработоспособный и игнорируется.

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

Несколько тонкостей для опытных пользователей:

• Если интерпретатор вызывается с опцией -O или переменная окружения PYTHONOPTIMIZE имеет непустое значение, интерпретатор генерирует оптими зированный байт-код и сохраняет его в ‘.pyo’-файлах. В настоящий момент опти мизация дает не слишком много: при этом удаляются инструкции assert, иг норируются инструкции ‘if debug:... ’, не сохраняется информация о нумерации строк в исходных ‘.py’-файлах. В этом случае оптимизируются все ис пользуемые модули, ‘.pyc’-файлы игнорируются.

• Опция -OO приводит к тому, что интерпретатор выполняет оптимизацию которая, в некоторых (редких) случаях, может привести к сбоям в работе программ. В настоящий момент, помимо действий, выполняемых с опцией -O, удаляются строки документации, давая более компактные ‘.pyo’-файлы. Так как некоторые программы могут рассчитывать на наличие строк документации, используйте эту опцию с осторожностью.

• Для программы, запускаемой из командной строки, байт-код никогда не записыва ется в ‘.pyc’- или ‘.pyo’-файл. Поэтому, если Вы хотите уменьшить время, требую 62 Глава 6. Модули щееся для загрузки, поместите большую часть кода в модуль, оставив в программе лишь загрузочную часть, которая импортирует этот модуль.

• Возможно использование модуля (или запуск программы) при наличии ‘.pyc’-файла (или ‘.pyo’-файла, если используется одна из опций -O или -OO), даже если отсут ствует ‘.py’-файл. Таким образом, Вы можете распространять библиотеки и про граммы в виде, из которого относительно сложно извлечь информацию об исполь зуемых алгоритмах.

• Модуль compileall позволяет создать ‘.pyc’- (или ‘.pyo’-) файлы для всех мо дулей в каталоге. Это может быть особенно полезно, если вы хотите ограничить доступ к каталогу, в котором находится библиотека. Заметим, что интерпретатор не будет использовать ‘.pyc’-файлы, если он запущен с включенной оптимизаци ей, и ‘.pyo’-файлы, если оптимизация выключена (если же отсутствует ‘.py’-файл, модуль окажется недоступным).

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

Набор таких модулей зависит от конфигурации, так, например, модуль amoeba присут ствует только в системах, которые поддерживают примитивы Amoeba. Один модуль за служивает особого внимания: sys, который присутствует всегда. Переменные sys.ps и sys.ps2 при работе в интерактивном режиме определяют строки, используемые для первичного и вторичного приглашения:

>>> import sys >>> sys.ps ’>>> ’ >>> sys.ps ’... ’ >>> sys.ps1 = ’C> ’ C> print ’!’ !

C> Переменная sys.path содержит список строк с именами каталогов, в которых происходит поиск модулей. Она инициализируется из значения переменной окружения PYTHONPATH и встроенного значения по умолчанию. Вы можете изменить ее значение, используя стандартные операции со списками:

>>> import sys >>> sys.path.append(’/ufs/guido/lib/python’) 6.5. Функция dir() 6.5 Функция dir() Для выяснения имен, определенных в модуле, можно использовать встроенную функцию dir(). Она возвращает отсортированный список строк:

>>> import fibo, sys >>> dir(fibo) [’name’, ’fib’, ’fib2’] >>> dir(sys) [’name’, ’argv’, ’builtin_module_names’, ’copyright’, ’exit’, ’maxint’, ’modules’, ’path’, ’ps1’, ’ps2’, ’setprofile’, ’settrace’, ’stderr’, ’stdin’, ’stdout’, ’version’] Без аргументов, dir() возвращает список имен, определенных в текущей области ви димости:

>>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() [’name’, ’a’, ’fib’, ’fibo’, ’sys’] Обратите внимание, что перечисляются имена объектов всех типов: переменные, моду ли, функции и т. д.

Список, возвращаемый функцией dir() не содержит имена встроенных функций и переменных — они определены в стандартном модуле builtin:

>>> import builtin >>> dir(builtin) [’AccessError’, ’AttributeError’, ’ConflictError’, ’EOFError’, ’IOError’, ’ImportError’, ’IndexError’, ’KeyError’, ’KeyboardInterrupt’, ’MemoryError’, ’NameError’, ’None’, ’OverflowError’, ’RuntimeError’, ’SyntaxError’, ’SystemError’, ’SystemExit’, ’TypeError’, ’ValueError’, ’ZeroDivisionError’, ’name’, ’abs’, ’apply’, ’chr’, ’cmp’, ’coerce’, ’compile’, ’dir’, ’divmod’, ’eval’, ’execfile’, ’filter’, ’float’, ’getattr’, ’hasattr’, ’hash’, ’hex’, ’id’, ’input’, ’int’, ’len’, ’long’, ’map’, ’max’, ’min’, ’oct’, ’open’, ’ord’, ’pow’, ’range’, ’raw_input’, ’reduce’, ’reload’, ’repr’, ’round’, ’setattr’, ’str’, ’type’, ’xrange’] 64 Глава 6. Модули 6.6 Пакеты Пакеты — способ структурирования пространств имен модулей, используя “точечную запись”. Например, имя модуля A.B обозначает подмодуль с именем A в пакете B.

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

Предположим, Вы хотите спроектировать совокупность модулей (“пакет”) для еди нообразной обработки звуковых файлов и данных. Существует множество форматов звуковых файлов (обычно распознаваемых по их расширению, например ‘.wav’, ‘.aiff’, ‘.au’), так что Вам необходимо создавать и поддерживать все возрастающий набор мо дулей для преобразования между различными форматами файлов. Вы можете захотеть выполнять множество различных операций над звуковыми данными (микширование, до бавление эха, частотная обработка, создание искусственного стереоэффекта), то есть, вдобавок, Вы будете писать нескончаемый поток модулей для выполнения этих опера ций. Вот примерная структура Вашего пакета (выраженная в терминах иерархической файловой системы):

Sound/ init.py Formats/ init.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py...

Effects/ init.py echo.py surround.py reverse.py...

Filters/ init.py equalizer.py vocoder.py karaoke.py...

Файл ‘init.py’ необходим для того, чтобы Python распознавал каталог, как со держащий пакет — таким образом предотвращается маскировка полноценных модулей, расположенных далее в путях поиска, каталогами с распространенными именами (таки ми как ‘string’). В простейшем случае, ‘init.py’ — пустой файл, но может содер 6.6. Пакеты жать код инициализации пакета и/или устанавливать переменную all, описанную ниже.

Пользователи пакета могут импортировать индивидуальные модули пакета, напри мер:

import Sound.Effects.echo В этом случае загружается модуль Sound.Effects.echo. На него нужно ссы латься по полному имени:

Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4) Вы можете использовать альтернативный способ импортирования подмодуля:

from Sound.Effects import echo В этом случае также загружается модуль Sound.Effects.echo, и делает его доступ ным для использования без префикса:

echo.echofilter(input, output, delay=0.7, atten=4) Еще один вариант — импортировать желаемую функцию или переменную непо средственно:

from Sound.Effects.echo import echofilter И в этом случае загружается модуль Sound.Effects.echo, но на этот раз, функция echofilter() становится доступной для использования непосредственно:

echofilter(input, output, delay=0.7, atten=4) Заметим, что при использовании ‘from package import item’, item может быть модулем, подпакетом или другим именем, определенном в пакете package, таким как функция, класс или переменная. Инструкция import сначала проверяет, определено ли имя item в пакете, если нет, считает его модулем и пытается загрузить. Если при загрузке возникает ошибка, генерируется исключение ImportError.

И наоборот, при использовании инструкции ‘import item.subitem.subsubitem’, каждая единица, кроме последней, должна быть пакетом. Последняя единица может быть модулем или пакетом, но не может быть классом, функцией или переменной, определенной в предыдущей единице.

66 Глава 6. Модули 6.6.1 Импортирование всего содержимого пакета (модуля) Что же происходит, когда пользователь использует ‘from Sound.Effects import *’? В идеале, интерпретатор должен каким-либо образом обойти файлы, на ходящиеся в каталоге пакета, и импортировать их все. К сожалению, такой подход не будет работать достаточно хорошо на таких платформах, как Macintosh и Windows, где файловая система не всегда имеет точную информацию о регистре букв в именах файлов.

В этом случае нет надежного пути узнать, с каким именем должен быть импортирован файл с именем ‘ECHO.PY’: echo, Echo или ECHO.

Единственный выход для автора — снабдить пакет явным указателем его со держимого. Инструкция import использует следующее соглашение: если в иници ализационном файле ‘init.py’ определен список с именем all, он исполь зуется в качестве списка имен модулей, которые должны импортироваться при ис пользовании ‘from package import *’. Поддержка этого списка в соответствии с текущим составом пакета возлагается на автора. Можно также не определять спи сок all, если авторы не считают уместным импортирование *. Например, файл ‘Sounds/Effects/init.py’ может содержать следующий код:

all = ["echo", "surround", "reverse"] Это означает, что from Sound.Effects import * импортирует три указанных мо дуля из пакета Sound.

Если список all не определен, ‘from Sound.Effects import *’ не будет импортировать все модули пакета Sound.Effects, а только имена, явным образом определенные в инициализационном файле ‘init.py’ (включая явно импортированные в нем модули). Кроме того, в текущую область видимости попадут модули пакета, явно загруженные предыдущими инструкциями import, например:

import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects import * В приведенном примере, модули echo и surround импортируются в текущее про странство имен, потому что они уже определены в пакете Sound.Effects на момент выполнения инструкции from... import.

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

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

6.6. Пакеты Мы рекомендуем стараться использовать запись ‘from package import specific_module’, за исключением случаев, когда необходимо использовать модули с одинаковыми именами из разных пакетов.

6.6.2 Связи между модулями пакета Часто возникает необходимость в связях между модулями одного пакета. Например, модуль surround может использовать модуль echo. В самом деле, подобные связи распространены настолько, что инструкция import сначала просматривает содержимое пакета, в который входит содержащий эту инструкцию модуль, и только потом в путях поиска модулей. Таким образом, модуль surround может просто использовать ‘import echo’ или ‘from echo import echofilter’.

Когда пакеты разделены на подпакеты (пакет Sound в примере), нет краткой запи си для ссылок между ответвлениями пакета — нужно использовать полное имя. Напри мер, если модуль Sound.Filters.vocoder должен использовать модуль echo пакета Sound.Effects, нужно использовать ‘from Sound.Effects import echo’.

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

7.1 Форматированный вывод До сих пор мы использовали два способа вывода: вывод значений выражений в интер активном режиме и с помощью инструкции print (третий способ — метод объектов файлов write()).

Часто возникает желание иметь больший контроль над форматированием вывода, чем просто выводить значения, разделенные пробелом. Конечно, Вы можете сами обра батывать строки: с помощью операций среза и объединения можно создать любое рас положение, какое только Вы сможете представить. Строки имеют методы, позволяющие дополнять их пробелами до необходимой ширины колонки1. Другой путь — использо вать оператор % со строкой в качестве левого аргумента. Оператор % интерпретирует строку справа как строку формата в стиле функции sprintf() в C, которую нужно применить к правому аргументу, и возвращает строку с результатом форматирования.

Безусловно, остается еще один вопрос: как получить строковое представление для значений различного типа? К счастью, Python предоставляет возможность преобразо вывать значение любого типа в строку: с помощью функции str(). Фактически язык предоставляет две функции для получения строкового представления — repr() (тот же эффект можно получить просто заключив выражение в обратные кавычки: ‘expr‘) и str(). Первый способ, например, используется интерпретатором для вывода значений выражений в интерактивном режиме, второй — для вывода аргументов инструкцией print. Функция str() по возможности возвращает представление, наиболее пригод ное для вывода, а функция repr() — для ввода выражения в интерактивном режиме.

Приведем несколько примеров:

>>> x = 10 * 3. Эти методы строк появились в версии 1.6 языка Python. В предыдущих версия они доступны в виде функций, определенных в модуле string.

7.1. Форматированный вывод Число 31.4 не может быть точно представлено в двоичном виде, поэтому:

>>> x 31. Однако функция str() выведет число с разумной точностью:

>>> y = 200* >>> s = ’ x ’ + str(x) + \... ’, y ’ + str(y) + ’...’ >>> print s x 31.4, y 40000...

Длинные целые числа записываются в языке Python с суффиксом ‘L’. Начиная с версии 1.6, функция str() его не выводит:

>>> repr(1000L) ’1000L’ >>> str(1000L) ’1000’ Строковое представление можно получить и для других типов:

>>> p = [x, y] >>> ps = repr(p) >>> ps ’[31.399999999999999, 40000]’ >>> ‘x, y, (’spam’, ’eggs’)‘ "(31.399999999999999, 40000, (’spam’, ’eggs’))" Функция repr() (или ‘‘) добавляет кавычки и записывает спецсимволы с помо щью управляющих последовательностей:

>>> hello = ’hello, world\n’ >>> print hello hello, world >>> hellos = ‘hello‘ >>> print hellos ’hello, world\012’ Выведем таблицу квадратов и кубов двумя описанными способами:

70 Глава 7. Ввод/вывод >>> for x in range(1, 11):

... print str(x).rjust(2), str(x*x).rjust(3),... #... print str(x*x*x).rjust(4)...

1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81 10 100 >>> for x in range(1,11):

... print ’%2d %3d %4d’ % (x, x*x, x*x*x)...

1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81 10 100 (Обратите внимание на то, что один пробел между колонками был добавлен инструкцией print.) Этот пример демонстрирует использование метода строк rjust(), который вы равнивает строку вправо в поле заданной ширины, дополняя ее слева пробелами. Ана логично действуют методы ljust() и center(). Они не выводят ничего — просто возвращают новую строку. Если исходная строка слишком длинная, она не обрезается, а возвращается в неизменном виде: обычно лучше внести беспорядок в расположение колонок, чем вывести неверное значение. (Если Вы действительно хотите ее обрезать, воспользуйтесь операцией среза: ‘s.ljust(n)[0:n]’.) Также может быть полезна функция zfill(), определенная в модуле string, которая дополняет слева нулями строку с числом, корректно обрабатывая знаки плюс и минус:

>>> import string >>> string.zfill(’12’, 5) ’00012’ 7.1. Форматированный вывод >>> string.zfill(’-3.14’, 7) ’-003.14’ >>> string.zfill(’3.14159265359’, 5) ’3.14159265359’ Использование оператора % выглядит примерно так:

>>> import math >>> print ’ PI %5.3f.’ % \... math.pi PI 3.142.

Если в строке нужно вывести несколько значений, в качестве правого операнда исполь зуется кортеж:

>>> table = {’Sjoerd’: 4127,... ’Jack’ : 4098,... ’Dcab’ : 7678} >>> for name, phone in table.items():

... print ’%-10s ==> %10d’ % (name, phone)...

Sjoerd ==> Dcab ==> Jack ==> Большинство форматов работают точно так же, как и в C. Однако, если типы аргументов не соответствуют формату, интерпретатор приводит их к необходимому типу (например, выражение любого типа может быть преобразовано в строку с помощью встроенной функции str()) или, если это невозможно, генерирует исключение2. Вы можете использовать * для того, чтобы передать отдельным параметром ширину поля или точность.

Заметим, что если правый аргумент кортеж, он всегда считается списком аргумен тов:

>>> def f(x):

... print ’ "%s"’ % x...

>>> f(1) "1" >>> f([1, 2]) "[1, 2]" >>> #,... f((1,)) "1" Из этого правила есть исключение: интерпретатор не будет преобразовывать строку к числовому типу.

72 Глава 7. Ввод/вывод >>> #... f((1, 2)) Traceback (most recent call last):

File "", line 1, in ?

File "", line 2, in f TypeError: not all arguments converted В данном случае надежнее будет использовать в качестве правого операнда кортеж, состоящий из одного элемента:

>>> def f(x):

... print ’ "%s"’ % (x,)...

>>> #... f((1,)) "(1,)" >>> f((1, 2)) "(1, 2)" В случае длинных строк формата, Вы можете захотеть ссылаться на переменные по имени вместо их положения. Это можно сделать, используя расширенную запись в виде %(name)format, например:

>>> table = {’Sjoerd’: 4127, ’Jack’: 4098,... ’Dcab’: 8637678} >>> print ’Jack: %(Jack)d;

Sjoerd: %(Sjoerd)d;

\... Dcab: %(Dcab)d’ % table Jack: 4098;

Sjoerd: 4127;

Dcab: Такая запись особенно полезна в комбинации со встроенной функцией vars(), которая возвращает словарь с переменными в текущей области видимости.

Более подробно операции над строками описаны в разделе 11.2.1.

7.2 Чтение и запись файлов Встроенная функция open() возвращает объект-файл (file) и обычно используется с двумя аргументами: ‘open(filename, mode)’.

>>> f=open(’/tmp/workfile’, ’wb’) >>> print f 7.2. Чтение и запись файлов Первый аргумент — строка, содержащая имя файла, второй аргумент — строка, содер жащая несколько символов, описывающих режим использования файла. Режим может быть ’r’, если файл открывается только для чтения, ’w’ — только для записи (су ществующий файл будет перезаписан), и ’a’ — для дописывания в конец файла. В режиме ’r+’ файл открывается сразу для чтения и записи. Аргумент mode не является обязательным: если он опущен, подразумевается ’r’.

В Windows (а в некоторых случаях и в Macintosh) файлы по умолчанию открывают ся в текстовом режиме — для того, чтобы открыть файл в двоичном режиме, необходимо к строке режима добавить ’b’. Следует помнить, что двоичные данные, такие как кар тинки в формате JPEG и даже текст в UNICODE, при чтении из файла или записи в файл, открытый в текстовом режиме, будут испорчены! Лучший способ оградить себя от неприятностей — всегда открывать файлы в двоичном режиме, даже на тех плат формах, где двоичный режим используется по умолчанию (возможно у Вас когда-нибудь возникнет желание запустить программу на другой платформе).

7.2.1 Методы объектов-файлов Примеры в этом разделе рассчитаны на то, что объект-файл f уже создан.

f.read(size) считывает и возвращает некоторое количество данных из файла.

Аргумент size не является обязательным. Если он опущен или отрицательный, будет считано все содержимое файла, в противном случае, будет считано не более size байт данных. По достижении конца файла, возвращается пустая строка ().

>>> f.read() # ’This is the entire file.\012’ >>> f.read() ’’ f.readline() считывает из файла одну строку. Возвращаемая строка всегда заканчивается символом новой строки (\n), за исключением последней строки файла, если файл не заканчивается символом новой строки. Это делает возвращаемое значение недвусмысленным: если readline() возвращает пустую строку — значит, достигнут конец файла, в то время как пустая строка будет представлена как ’\n’.

>>> f.readline() # ’This is the first line of the file.\012’ >>> f.readline() # ’Second line of the file\012’ >>> f.readline() # ’’ f.readlines() считывает все содержимое файла, и возвращает список строк.

74 Глава 7. Ввод/вывод >>> f.readlines() [’This is the first line of the file.\012’, ’Second line of the file\012’] f.write(s) записывает содержимое строки s в файл.

>>> f.write(’This is a test\n’) f.tell() возвращает текущее положение в файле в байтах, отсчитываемое от начала файла. Чтобы изменить текущее положение, используйте ‘f.seek(offset, from_what)’. Новое положение вычисляется путем добавления offset к точке от счета. Точка отсчета выбирается в зависимости от значения аргумента from_what:

0 соответствует началу файла (используется по умолчанию, если метод вызывается с одним аргументом), 1 — текущему положению и 2 — концу файла.

>>> f=open(’/tmp/workfile’, ’rb+’) >>> f.write(’0123456789abcdef’) >>> f.seek(5) # Go to the 5th byte in the file >>> f.read(1) ’5’ >>> f.seek(-3, 2) # Go to the 3rd byte before the end >>> f.read(1) ’d’ После того, как Вы закончили все операции с файлом, закройте файл с помощью f.close(). При попытке использовать закрытый файл для операций чтения/записи генерируется исключение ValueError:

>>> f.close() >>> f.read() Traceback (innermost last):

File "", line 1, in ?

ValueError: I/O operation on closed file Объекты-файлы имеют еще несколько методов, используемых не так часто (isatty(), truncate()). Для получения о них полной информации смотрите раздел 11.7.

7.2.2 Модуль pickle Строки легко могут быть записаны в файл и считаны из него. Числа требуют приложения небольших усилий, так как метод read() всегда возвращает строки, которые нужно обработать, например, с помощью функции int(). Однако задача сильно усложняется, 7.2. Чтение и запись файлов если Вы хотите сохранять более сложные типы данных, такие как списки, словари или экземпляры классов.

Чтобы пользователю не приходилось постоянно писать и отлаживать код для со хранения сложных типов данных, Python предоставляет для этих целей стандартный модуль pickle. Этот изумительный модуль позволяет получить представление почти любого объекта (даже некоторые формы кода) в виде набора байтов (строки), одинако вого для всех платформ. Такой процесс называют “консервированием” (pickling). Такое представление (законсервированный объект) можно сохранить в файле или передать че рез сетевое соединение на другую машину. К считанному из файла или принятому на другой машине законсервированному объекту может быть применена операция восста новления (unpickling).

Если у Вас есть объект x и файловый объект f, открытый для записи, простейший способ сохранить объект потребует всего одну строку кода:

pickle.dump(x, f) Так же просто можно восстановить объект (f — файловый объект, открытый для чте ния):

x = pickle.load(f) Для получения полного представления о возможностях модуля pickle, смотрите его описание в третьей части книги.

Использование модуля pickle является стандартным в языке Python путем сохра нения так называемых долгоживущих (persistent) объектов для дальнейшего использо вания. Модуль настолько часто используется, что многие авторы дополнительных мо дулей заботятся о том, чтобы новые типы данных (например, матрицы) могли быть правильно законсервированы.

Глава Ошибки и исключения До сих пор мы лишь упоминали об ошибках, но если Вы пробовали приведенные приме ры, то могли увидеть некоторые из них. Можно выделить (как минимум) два различимых типа ошибок: синтаксические ошибки и исключения1.

8.1 Синтаксические ошибки Синтаксические ошибки, пожалуй, чаще всего встречаются во время изучения языка:

>>> while 1 print ’Hello world’ File "", line while 1 print ’Hello world’ ^ SyntaxError: invalid syntax Синтаксический анализатор выводит строку, содержащую ошибку, и указывает место, где ошибка была обнаружена. Ошибка обычно вызвана лексемой, предшествующей стрелке: в приведенном примере, ошибка обнаружена на месте ключевого слова print, так как перед ним отсутствует двоеточие (‘:’). Имя файла и номер строки выводится для того, чтобы Вы знали, где искать ошибку в случае, если инструкции считываются из файла.

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

>>> 10 * (1/0) Traceback (innermost last):

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

8.3. Обработка исключений File "", line ZeroDivisionError: integer division or modulo >>> 4 + spam* Traceback (innermost last):

File "", line NameError: spam >>> ’2’ + Traceback (innermost last):

File "", line TypeError: illegal argument type for built-in operation Последняя строка сообщения показывает, что произошло. Исключения бывают раз ного типа — он выводится в сообщении. Типы исключений в приведенном примере:

ZeroDivisionError, NameError и TypeError. Имена стандартных исключений яв ляются встроенными идентификаторами, но не являются зарезервированными ключевы ми словами.

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

В главе 13 перечислены все встроенные исключения и их назначение.

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

Посмотрите на следующий пример, в котором пользователю будет выдаваться пригла шение до тех пор, пока не будет введено целое число или выполнение не будет прервано (обычно Ctrl-C). Во втором случае генерируется исключение KeyboardInterrupt.

>>> while 1:

... try:

... x = int(raw_input(... ",, : "))... break... except ValueError:

... print "...."

...

Инструкция try работает следующим образом.

• Сначала выполняется ветвь try (инструкции, находящиеся между ключевыми словами try и except).

78 Глава 8. Ошибки и исключения • Если не возникает исключительной ситуации, ветвь except пропускается и вы полнение инструкции try завершается.

• Если во время выполнения ветви try генерируется исключение, оставшаяся часть ветви пропускается. Далее, если тип (класс) исключения соответствует указан ному после ключевого слова except, выполняется ветвь except и выполнение инструкции try завершается.

• Если исключение не соответствует указанному после ключевого слова except, то оно передается внешнему блоку try или, если обработчик не найден, исключение считается не перехваченным, выполнение прерывается и выводится сообщение об ошибке.

Инструкция try может иметь более одной ветви except, определяя обработчики для разных исключений. Выполняться будет (как максимум) только один из них. Об рабатываются только исключения, сгенерированные в соответствующей ветви try, но не в других обработчиках инструкции try. После ключевого слова except может быть указано несколько типов исключений в виде кортежа:

... except (RuntimeError, TypeError, NameError):

... pass В последней ветви except тип исключения может быть опущен — в этом слу чае будут обрабатываться все исключения. Используйте такую запись с особой осто рожностью — так Вы легко можете замаскировать реальные ошибки! Перехват всех исключений можно использовать для вывода сообщения об ошибке, а затем повторно сгенерировать его (позволяя обрабатывать исключение в другом месте):

import sys try:

f = open(’myfile.txt’) s = f.readline() i = int(s.strip()) except IOError, exc:

print " /", exc except ValueError:

print "."

except:

print " :", sys.exc_info()[0] raise # # После всех ветвей except, инструкция try может содержать ветвь else, кото рая будет выполняться в случае, если во время выполнения ветви try исключения не генерируются. Например:

8.3. Обработка исключений for arg in sys.argv[1:]:

try:

f = open(arg, ’r’) except IOError:

print ’ ’, arg else:

print arg, ’’, len(f.readlines()), \ ’’ f.close() Обычно лучше использовать ветвь else, чем добавлять код в основную ветвь инструк ции try, так как это позволяет избежать обработки исключений, сгенерированных ко дом, который Вы вовсе не собирались защищать.

Исключение может иметь ассоциированное с ним значение — аргумент, пере данный классу исключения при инициализации. Наличие и тип аргумента зависит от типа исключения. Ассоциированное значение используется при получении для исключе ния строкового значения. Чтобы получить значение исключения, в ветви except после класса исключения (или кортежа классов) укажите переменную:

>>> try:

... spam()... except NameError, x:

... print ’’, x, ’ ’...

spam Если исключение не обрабатывается, значение исключения выводится в сообщении об ошибке после имени класса исключения.

Обработчик перехватывает не только исключения, сгенерированные непосред ственно в блоке try, но и в вызываемых из него функциях. Например:

>>> def this_fails():

... x = 1/...

>>> try:

... this_fails()... except ZeroDivisionError, exc:

... print ’ :’, exc...

Pages:     || 2 | 3 | 4 | 5 |   ...   | 7 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.