Об авторе
Предисловие
Часть I.
Глава 1.
Почему программисты используют Python?
Является ли Python «языком сценариев»?
Все хорошо, но есть ли у него недостатки?
Кто в наше время использует Python?
Что можно делать с помощью Python?
Как осуществляется поддержка Python?
В чем сильные стороны Python?
Какими преимуществами обладает Python перед языком X?
В заключение
Закрепление пройденного
Глава 2.
Введение в интерпретатор Python
Выполнение программы
Разновидности модели выполнения
В заключение
Закрепление пройденного
Глава 3.
Интерактивный режим
Системная командная строка и файлы
Щелчок на ярлыке файла
Импортирование и перезагрузка модулей
Запуск модулей с помощью функции exec
Пользовательский интерфейс IDLE
Другие интегрированные среды разработки
Другие способы запуска
Какие способы следует использовать?
В заключение
Закрепление пройденного
Часть II.
Глава 4.
Зачем нужны встроенные типы?
Числа
Строки
Списки
Словари
Кортежи
Файлы
Другие базовые типы
В заключение
Закрепление пройденного
Глава 5.
Базовые числовые типы
Числа в действии
Другие числовые типы
Числовые расширения
В заключение
Закрепление пройденного
Глава 6.
Отсутствие инструкций объявления
Разделяемые ссылки
Динамическая типизация повсюду
В заключение
Закрепление пройденного
Ответы
Глава 7.
Литералы строк
Строки в действии
Строковые методы
Выражения форматирования строк
Метод форматирования строк
Общие категории типов
В заключение
Закрепление пройденного
Глава 8.
Списки
Списки в действии
Словари
Словари в действии
В заключение
Закрепление пройденного
Глава 9.
Кортежи
Кортежи в действии
Файлы
Пересмотренный перечень категорий типов
Гибкость объектов
Ссылки и копии
Сравнивание, равенство и истина
Иерархии типов данных в языке Python
Другие типы в Python
Ловушки встроенных типов
В заключение
Закрепление пройденного
Часть III.
Глава 10.
Структура программы на языке Python
История о двух if
Короткий пример
В заключение
Закрепление пройденного
Глава 11.
Инструкции присваивания
Инструкции выражений
Операция print
В заключение
Закрепление пройденного
Глава 12.
Условные инструкции if
Синтаксические правила языка Python
Проверка истинности
Трехместное выражение if/else
В заключение
Закрепление пройденного
Глава 13.
Циклы while
break, continue, pass и else
Циклы for
Приемы программирования циклов
В заключение
Закрепление пройденного
Глава 14.
Итераторы
Генераторы списков
Новые итерируемые объекты в Python 3.0
Другие темы, связанные с итераторами
В заключение
Закрепление пройденного
Глава 15.
Источники документации в языке Python
Типичные ошибки программирования
В заключение
Закрепление пройденного
Часть IV.
Глава 16.
Зачем нужны функции?
Создание функций
Первый пример
Второй пример
В заключение
Закрепление пройденного
Глава 17.
Области видимости в языке Python
Инструкция global
Области видимости и вложенные функции
Инструкция nonlocal
В заключение
Закрепление пройденного
Глава 18.
Передача аргументов
Специальные режимы
Функция поиска минимума
Универсальные функции
Имитация функции print в Python 3.0
В заключение
Закрепление пройденного
Глава 19.
Концепции проектирования функций
Рекурсивные функции
Функции – это объекты
Анонимные функции
Отображение функций
Средства функционального программирования
В заключение
Закрепление пройденного
Глава 20.
Еще раз о генераторах списков
Еще раз об итераторах
Краткая сводка по синтаксису генераторов в 3.0
Хронометраж итерационных альтернатив
Типичные ошибки при работе с функциями
В заключение
Закрепление пройденного
Часть V.
Глава 21.
Зачем нужны модули?
Архитектура программы на языке Python
Как работает импорт
Путь поиска модулей
В заключение
Закрепление пройденного
Глава 22.
Создание модуля
Использование модулей
Пространства имен модулей
Повторная загрузка модулей
В заключение
Закрепление пройденного
Глава 23.
Основы операции импортирования пакетов
Пример импортирования пакета
Когда используется операция
Импортирование относительно пакета
В заключение
Закрепление пройденного
Глава 24.
Сокрытие данных в модулях
Включение будущих возможностей языка
Смешанные режимы использования
Изменение пути поиска модулей
Расширение as для инструкций import и from
Модули – это объекты
Импортирование модулей
Транзитивная перезагрузка модулей
Концепции проектирования модулей
Типичные проблемы при работе с модулями
В заключение
Закрепление пройденного
Часть VI.
Глава 25.
Зачем нужны классы?
ООП с высоты 30 000 футов
В заключение
Закрепление пройденного
Глава 26.
Классы генерируют
Классы адаптируются посредством наследования
Классы могут переопределять операторы языка Python
Самый простой в мире класс на языке Python
Классы и словари
В заключение
Закрепление пройденного
Глава 27.
Шаг 1
Шаг 2
Шаг 3
Шаг 4
Шаг 5
Шаг 6
Шаг 7 (последний)
Рекомендации на будущее
В заключение
Закрепление пройденного
Глава 28.
Инструкция class
Методы
Наследование
Пространства имен
Еще раз о строках документирования
Классы и модули
В заключение
Закрепление пройденного
Глава 29.
Доступ к элементам по индексу и извлечение срезов
Итерации по индексам
Итераторы
Проверка на вхождение
Обращения к атрибутам
Строковое представление объектов
Правостороннее сложение и операция приращения
Операция вызова
Функциональные интерфейсы
Сравнивание
Проверка логического значения
В заключение
Закрепление пройденного
Глава 30.
Python и ООП
ООП и наследование
ООП и композиция
ООП и делегирование
Псевдочастные атрибуты класса
Методы – это объекты
Множественное наследование
Классы – это объекты
Прочие темы, связанные с проектированием
В заключение
Закрепление пройденного
Глава 31.
Расширение встроенных типов
Классы «нового стиля»
Изменения в классах нового стиля
Другие расширения в классах нового стиля
Статические методы и методы класса
Декораторы и метаклассы
Типичные проблемы при работе с классами
В заключение
Закрепление пройденного
Часть VII.
Глава 32.
Зачем нужны исключения?
Обработка исключений
В заключение
Закрепление пройденного
Глава 33.
Инструкция try/except/else
Инструкция try/finally
Объединенная инструкция try/except/finally
Инструкция raise
Инструкция assert
Контекстные менеджеры with/as
В заключение
Закрепление пройденного
Глава 34.
Исключения
Исключения на основе классов
В чем преимущества иерархий исключений?
Классы встроенных исключений
Определение текста исключения
Передача данных в экземплярах
В заключение
Закрепление пройденного
Глава 35.
Вложенные обработчики исключений
Идиомы исключений
Советы по применению
Заключение по основам языка
В заключение
Закрепление пройденного
Часть VIII.
Глава 36.
Изменения в Python 3.0, касающиеся строк
Основы строк
Примеры использования строк в Python 3.0
Кодирование строк Юникода
Использование объектов bytes в Python 3.0
Использование объектов bytearray в 3.0 (и 2.6)
Использование текстовых и двоичных файлов
Использование файлов Юникода
Другие инструменты
В заключение
Закрепление пройденного
Глава 37.
Зачем нужно управлять атрибутами?
Свойства
Дескрипторы
__getattr__ и __getattribute__
Пример
В заключение
Закрепление пройденного
Глава 38.
Что такое декоратор?
Основы
Программирование декораторов функций
Программирование декораторов классов
Непосредственное управление
Пример
Пример
В заключение
Закрепление пройденного
Глава 39.
Нужны или не нужны метаклассы
Модель метаклассов
Объявление метаклассов
Программирование метаклассов
Пример
Пример
В заключение
Закрепление пройденного
Часть IX.
Приложение A.
Установка интерпретатора Python
Настройка Python
Параметры командной строки интерпретатора
Дополнительная информация
Приложение B.
Часть I. Введение
Часть II. Типы и операции
Часть III. Инструкции и синтаксис
Часть IV. Функции
Часть V. Модули
Часть VI. Классы и ООП
Часть VII. Исключения и инструменты
Алфавитный указатель
Текст
                    Learning

Python
Forth Edition

Mark Lutz


Изучаем Python Четвертое издание Марк Лутц Санкт-Петербург – Москва 2011
Марк Лутц Изучаем Python, 4-е издание Перевод А. Киселева Главный редактор Зав. редакцией Выпускающий редактор Редактор Корректор Верстка А. Галунов Н. Макарова П. Щеголев Ю. Бочина С. Минин К. Чубаров Лутц М. Изучаем Python, 4-е издание. – Пер. с англ. – СПб.: Символ-Плюс, 2011. – 1280 с., ил. ISBN 978-5-93286-159-2 Такие известные компании, как Google и Intel, Cisco и Hewlett-Packard, используют язык Python, выбрав его за гибкость, простоту использования и обеспечиваемую им высокую скорость разработки. Он позволяет создавать эффективные и надежные проекты, которые легко интегрируются с программами и инструментами, написанными на других языках. Четвертое издание «Изучаем Python» – это учебник, написанный доступным языком, рассчитанный на индивидуальную скорость обучения и основанный на материалах учебных курсов, которые автор, Марк Лутц, ведет уже на протяжении десяти лет. Издание значительно расширено и дополнено в соответствии с изменениями, появившимися в новой версии 3.0. В книге представлены основные типы объектов в языке Python, порядок их создания и работы с ними, а также функции как основной процедурный элемент языка. Рассматриваются методы работы с модулями и дополнительными объектно-ориентированными инструментами языка Python – классами. Включены описания моделей и инструкций обработки исключений, а также обзор инструментов разработки, используемых при создании крупных программ. Каждая глава завершается контрольными вопросами с ответами на закрепление пройденного материала, а каждая часть – упражнениями, решения которых приведены в приложении В. Книга была дополнена примечаниями о наиболее существенных расширениях языка, по­явившихся в версии Python 3.1. ISBN 978-5-93286-159-2 ISBN 978-0-596-15806-4 (англ) © Издательство Символ-Плюс, 2010 Authorized translation of the English edition © 2009 O’Reilly Media Inc.. This trans­ lation is pub­lished and sold by permission of O’Reilly Media Inc., the owner of all rights to publish and sell the same. Все права на данное издание защищены Законодательством РФ, включая право на полное или час­ тичное воспроизведение в любой форме. Все товарные знаки или зарегистрированные товарные зна­ ки, упоминаемые в настоящем издании, являются собственностью соответствующих фирм. Издательство «Символ-Плюс». 199034, Санкт-Петербург, 16 линия, 7, тел. (812) 324-5353, www.symbol.ru. Лицензия ЛП N 000054 от 25.12.98. Подписано в печать 22.10.2010. Формат 70×100 1/16. Печать офсетная. Объем 80 печ. л. Тираж ХХ00 экз. Заказ № Отпечатано с готовых диапозитивов в ГУП «Типография «Наука» 199034, Санкт-Петербург, 9 линия, 12.
Посвящается Вере. Ты – жизнь моя.
Об авторе Марк Лутц (Mark Lutz) является ведущим специалистом в области обучения языку программирования Python и автором самых ранних и наиболее популярных публикаций. Он известен в сообществе пользователей Python своими новаторскими идеями. Лутц – автор книг «Programming Python»1 и «Python Pocket Refe­ren­ ce», выпущенных издательством O’Reilly и претерпевших несколько изданий. Он использует Python и занимается его популяризацией начиная с 1992 года. Книги об этом языке программирования он начал писать в 1995 году, а его преподаванием стал заниматься с 1997 года. На начало 2009 года Марк провел 225 курсов, обучил примерно 3500 студентов и написал книги по языку Python, суммарный тираж которых составил около четверти миллиона экземпляров. Книги Лутца переведены более чем на десять языков. Марк обладает степенями бакалавра и магистра в области информатики, закончил университет штата Висконсин (США). На протяжении последних 25 лет занимался разработкой компиляторов, инструментальных средств программиста, приложений и разнообразных систем в архитектуре клиент-сервер. Связаться с Марком можно через вебсайт http://www.rmi.net/~lutz. 1 Лутц М. «Программирование на Python», 2-е изд. – Пер. с англ. – СПб.: Символ-Плюс, 2002. Четвертое издание этой книги выйдет в 2011 году.
Оглавление Об авторе.................................................................................... 6 Предисловие.............................................................................. 17 Часть I. Введение....................................................................... 39 Глава 1. Python в вопросах и ответах......................................... 41 Почему программисты используют Python?............................... 41 Является ли Python «языком сценариев»?................................ 44 Все хорошо, но есть ли у него недостатки?................................. 45 Кто в наше время использует Python?....................................... 46 Что можно делать с помощью Python?...................................... 48 Как осуществляется поддержка Python?................................... 52 В чем сильные стороны Python?............................................... 52 Какими преимуществами обладает Python перед языком X? ....... 57 В заключение........................................................................ 58 Закрепление пройденного.......................................................59 Глава 2. Как Python запускает программы................................. 63 Введение в интерпретатор Python............................................. 63 Выполнение программы......................................................... 64 Разновидности модели выполнения..........................................69 В заключение........................................................................ 75 Закрепление пройденного....................................................... 75 Глава 3. Как пользователь запускает программы....................... 77 Интерактивный режим........................................................... 77 Системная командная строка и файлы...................................... 84 Щелчок на ярлыке файла.......................................................90 Импортирование и перезагрузка модулей.................................. 94 Запуск модулей с помощью функции exec ............................... 101 Пользовательский интерфейс IDLE........................................ 102 Другие интегрированные среды разработки............................. 108 Другие способы запуска........................................................ 109 Какие способы следует использовать?..................................... 112 В заключение...................................................................... 114 Закрепление пройденного..................................................... 114
8 Оглавление Часть II. Типы и операции........................................................ 119 Глава 4. Введение в типы объектов языка Python.................... 121 Зачем нужны встроенные типы?............................................ 122 Числа................................................................................. 125 Строки............................................................................... 126 Списки............................................................................... 133 Словари.............................................................................. 137 Кортежи............................................................................. 144 Файлы............................................................................... 145 Другие базовые типы............................................................ 147 В заключение...................................................................... 151 Закрепление пройденного..................................................... 151 Глава 5. Числа........................................................................ 153 Базовые числовые типы........................................................ 153 Числа в действии................................................................. 162 Другие числовые типы......................................................... 177 Числовые расширения ......................................................... 191 В заключение...................................................................... 191 Закрепление пройденного..................................................... 192 Глава 6. Интерлюдия о динамической типизации.................... 194 Отсутствие инструкций объявления....................................... 194 Разделяемые ссылки............................................................ 199 Динамическая типизация повсюду......................................... 204 В заключение...................................................................... 205 Закрепление пройденного..................................................... 205 Ответы............................................................................... 205 Глава 7. Строки....................................................................... 207 Литералы строк................................................................... 210 Строки в действии................................................................ 217 Строковые методы............................................................... 227 Выражения форматирования строк ....................................... 234 Метод форматирования строк................................................ 239 Общие категории типов........................................................ 249 В заключение...................................................................... 251 Закрепление пройденного..................................................... 251 Глава 8. Списки и словари....................................................... 253 Списки............................................................................... 253 Списки в действии............................................................... 256 Словари.............................................................................. 264 Словари в действии.............................................................. 266 В заключение...................................................................... 282 Закрепление пройденного..................................................... 282
Оглавление 9 Глава 9. Кортежи, файлы и все остальное................................ 284 Кортежи............................................................................. 284 Кортежи в действии............................................................. 286 Файлы............................................................................... 289 Пересмотренный перечень категорий типов............................. 301 Гибкость объектов............................................................... 302 Ссылки и копии................................................................... 303 Сравнивание, равенство и истина........................................... 306 Иерархии типов данных в языке Python.................................. 310 Другие типы в Python........................................................... 312 Ловушки встроенных типов.................................................. 313 В заключение...................................................................... 315 Закрепление пройденного..................................................... 316 Часть III. Инструкции и синтаксис............................................ 321 Глава 10. Введение в инструкции языка Python........................ 323 Структура программы на языке Python................................... 323 История о двух if................................................................. 326 Короткий пример: интерактивные циклы............................... 334 В заключение...................................................................... 340 Закрепление пройденного..................................................... 340 Глава 11. Присваивание, выражения и print............................. 342 Инструкции присваивания................................................... 342 Инструкции выражений....................................................... 360 Операция print.................................................................... 362 В заключение...................................................................... 374 Закрепление пройденного..................................................... 374 Глава 12. Условная инструкция if и синтаксические правила.... 376 Условные инструкции if....................................................... 376 Синтаксические правила языка Python................................... 379 Проверка истинности........................................................... 385 Трехместное выражение if/else.............................................. 387 В заключение...................................................................... 390 Закрепление пройденного..................................................... 390 Глава 13. Циклы while и for..................................................... 392 Циклы while....................................................................... 392 break, continue, pass и else..................................................... 394 Циклы for........................................................................... 400 Приемы программирования циклов....................................... 407 В заключение...................................................................... 415 Закрепление пройденного..................................................... 415
10 Оглавление Глава 14. Итерации и генераторы, часть 1................................ 417 Итераторы: первое знакомство............................................... 417 Генераторы списков: первое знакомство.................................. 425 Новые итерируемые объекты в Python 3.0............................... 433 Другие темы, связанные с итераторами................................... 439 В заключение...................................................................... 439 Закрепление пройденного..................................................... 439 Глава 15. Документация.......................................................... 441 Источники документации в языке Python............................... 441 Типичные ошибки программирования.................................... 453 В заключение...................................................................... 456 Закрепление пройденного..................................................... 456 Часть IV. Функции.................................................................... 459 Глава 16. Основы функций...................................................... 461 Зачем нужны функции?........................................................ 462 Создание функций............................................................... 463 Первый пример: определения и вызовы.................................. 466 Второй пример: пересечение последовательностей.................... 469 В заключение...................................................................... 472 Закрепление пройденного..................................................... 472 Глава 17. Области видимости.................................................. 474 Области видимости в языке Python......................................... 474 Инструкция global............................................................... 482 Области видимости и вложенные функции.............................. 487 Инструкция nonlocal............................................................ 494 В заключение...................................................................... 502 Закрепление пройденного..................................................... 502 Глава 18. Аргументы............................................................... 505 Передача аргументов............................................................ 505 Специальные режимы сопоставления аргументов..................... 511 Функция поиска минимума................................................... 525 Универсальные функции для работы с множествами................ 528 Имитация функции print в Python 3.0.................................... 530 В заключение...................................................................... 533 Закрепление пройденного..................................................... 534 Глава 19. Расширенные возможности функций....................... 536 Концепции проектирования функций..................................... 536 Рекурсивные функции......................................................... 538 Функции – это объекты: атрибуты и аннотации....................... 542 Анонимные функции: lambda................................................ 548
Оглавление 11 Отображение функций на последовательности: map.................. 554 Средства функционального программирования: filter и reduce...................................................................... 556 В заключение...................................................................... 557 Закрепление пройденного..................................................... 558 Глава 20. Итераторы и генераторы.......................................... 560 Еще раз о генераторах списков: функциональные инструменты.............................................. 560 Еще раз об итераторах: генераторы......................................... 567 Краткая сводка по синтаксису генераторов в 3.0...................... 583 Хронометраж итерационных альтернатив............................... 586 Типичные ошибки при работе с функциями............................. 596 В заключение...................................................................... 600 Закрепление пройденного..................................................... 601 Часть V. Модули....................................................................... 605 Глава 21. Модули: общая картина........................................... 607 Зачем нужны модули?.......................................................... 608 Архитектура программы на языке Python............................... 608 Как работает импорт............................................................ 612 Путь поиска модулей............................................................ 614 В заключение...................................................................... 620 Закрепление пройденного..................................................... 621 Глава 22. Основы программирования модулей....................... 623 Создание модуля.................................................................. 623 Использование модулей........................................................ 624 Пространства имен модулей.................................................. 630 Повторная загрузка модулей................................................. 635 В заключение...................................................................... 639 Закрепление пройденного..................................................... 640 Глава 23. Пакеты модулей...................................................... 641 Основы операции импортирования пакетов............................. 641 Пример импортирования пакета............................................ 645 Когда используется операция импортирования пакетов? .......... 647 Импортирование относительно пакета.................................... 650 В заключение...................................................................... 663 Закрепление пройденного..................................................... 664 Глава 24. Дополнительные возможности модулей.................. 665 Сокрытие данных в модулях................................................. 665 Включение будущих возможностей языка............................... 666
12 Оглавление Смешанные режимы использования: __name__ и __main__........................................................... 667 Изменение пути поиска модулей............................................ 672 Расширение as для инструкций import и from.......................... 673 Модули – это объекты: метапрограммы................................... 674 Импортирование модулей по имени в виде строки.................... 677 Транзитивная перезагрузка модулей ...................................... 678 Концепции проектирования модулей...................................... 681 Типичные проблемы при работе с модулями............................ 682 В заключение...................................................................... 688 Закрепление пройденного..................................................... 688 Часть VI. Классы и ООП............................................................ 693 Глава 25. ООП: общая картина................................................ 695 Зачем нужны классы?.......................................................... 696 ООП с высоты 30 000 футов................................................... 697 В заключение...................................................................... 706 Закрепление пройденного..................................................... 707 Глава 26. Основы программирования классов......................... 709 Классы генерируют множество экземпляров объектов.............. 709 Классы адаптируются посредством наследования..................... 713 Классы могут переопределять операторы языка Python............. 717 Самый простой в мире класс на языке Python.......................... 721 Классы и словари ................................................................ 723 В заключение...................................................................... 725 Закрепление пройденного..................................................... 726 Глава 27. Более реалистичный пример.................................... 728 Шаг 1: создание экземпляров ................................................ 729 Шаг 2: добавление методов, определяющих поведение.............. 733 Шаг 3: перегрузка операторов................................................ 737 Шаг 4: адаптация поведения с помощью подклассов................. 739 Шаг 5: адаптация конструкторов........................................... 745 Шаг 6: использование инструментов интроспекции.................. 750 Шаг 7 (последний): сохранение объектов в базе данных............. 757 Рекомендации на будущее..................................................... 763 В заключение...................................................................... 765 Закрепление пройденного..................................................... 766 Глава 28. Подробнее о программировании классов................. 769 Инструкция class................................................................. 769 Методы.............................................................................. 772 Наследование...................................................................... 775
Оглавление 13 Пространства имен: окончание истории ................................. 781 Еще раз о строках документирования..................................... 790 Классы и модули. ................................................................ 791 В заключение...................................................................... 792 Закрепление пройденного..................................................... 792 Глава 29. Перегрузка операторов............................................ 794 Доступ к элементам по индексу и извлечение срезов: __getitem__ и __setitem__.................................................... 797 Итерации по индексам: __getitem__....................................... 800 Итераторы: __iter__ и __next__............................................. 802 Проверка на вхождение: __contains__, __iter__ и __getitem__...................................... 807 Обращения к атрибутам: __getattr__ и __setattr__................... 809 Строковое представление объектов: __repr__ и __str__............. 812 Правостороннее сложение и операция приращения: __radd__ и __iadd__............................................................ 814 Операция вызова: __call__.................................................... 816 Функциональные интерфейсы и программный код обратного вызова..................................... 818 Сравнивание: __lt__, __gt__ и другие..................................... 820 Проверка логического значения: __bool__ и __len__................. 821 В заключение...................................................................... 825 Закрепление пройденного..................................................... 826 Глава 30. Шаблоны проектирования с классами...................... 828 Python и ООП...................................................................... 828 ООП и наследование: взаимосвязи типа «является»................................................ 830 ООП и композиция: взаимосвязи типа «имеет»........................ 832 ООП и делегирование: объекты-обертки.................................. 837 Псевдочастные атрибуты класса............................................ 839 Методы – это объекты: связанные и несвязанные методы........................................... 842 Множественное наследование: примесные классы.................... 849 Классы – это объекты: универсальные фабрики объектов.......................................... 861 Прочие темы, связанные с проектированием. .......................... 863 В заключение...................................................................... 863 Закрепление пройденного..................................................... 864 Глава 31. Дополнительные возможности классов..................... 865 Расширение встроенных типов.............................................. 866 Классы «нового стиля»......................................................... 869 Изменения в классах нового стиля......................................... 870
14 Оглавление Другие расширения в классах нового стиля............................. 880 Статические методы и методы класса...................................... 887 Декораторы и метаклассы: часть 1......................................... 896 Типичные проблемы при работе с классами............................. 901 В заключение...................................................................... 907 Закрепление пройденного..................................................... 908 Часть VII. Исключения и инструменты.................................... 917 Глава 32. Основы исключений................................................ 919 Зачем нужны исключения?................................................... 920 Обработка исключений: краткий обзор................................... 921 В заключение...................................................................... 927 Закрепление пройденного..................................................... 928 Глава 33. Особенности использования исключений................. 929 Инструкция try/except/else.................................................. 929 Инструкция try/finally......................................................... 936 Объединенная инструкция try/except/finally.......................... 939 Инструкция raise................................................................. 943 Инструкция assert............................................................... 946 Контекстные менеджеры with/as........................................... 948 В заключение...................................................................... 952 Закрепление пройденного..................................................... 952 Глава 34. Объекты исключений............................................... 954 Исключения: назад в будущее............................................... 955 Исключения на основе классов.............................................. 956 В чем преимущества иерархий исключений? .......................... 959 Классы встроенных исключений............................................ 962 Определение текста исключения............................................ 965 Передача данных в экземплярах и реализация поведения ......... 966 В заключение...................................................................... 968 Закрепление пройденного..................................................... 969 Глава 35. Использование исключений..................................... 971 Вложенные обработчики исключений..................................... 971 Идиомы исключений............................................................ 975 Советы по применению и типичные проблемы исключений........................................ 980 Заключение по основам языка............................................... 984 В заключение...................................................................... 990 Закрепление пройденного..................................................... 991
15 Оглавление Часть VIII. Расширенные возможности................................... 993 Глава 36. Юникод и строки байтов.......................................... 995 Изменения в Python 3.0, касающиеся строк............................. 996 Основы строк...................................................................... 997 Примеры использования строк в Python 3.0.......................... 1003 Кодирование строк Юникода............................................... 1006 Использование объектов bytes в Python 3.0............................ 1015 Использование объектов bytearray в 3.0 (и 2.6) ...................... 1018 Использование текстовых и двоичных файлов....................... 1021 Использование файлов Юникода.......................................... 1026 Другие инструменты для работы со строками в Python 3.0....... 1031 В заключение.................................................................... 1039 Закрепление пройденного................................................... 1040 Глава 37. Управляемые атрибуты......................................... 1043 Зачем нужно управлять атрибутами?................................... Свойства........................................................................... Дескрипторы..................................................................... __getattr__ и __getattribute__............................................. Пример: проверка атрибутов............................................... В заключение.................................................................... Закрепление пройденного................................................... 1043 1045 1050 1059 1078 1084 1084 Глава 38. Декораторы........................................................... 1087 Что такое декоратор?......................................................... Основы............................................................................. Программирование декораторов функций............................. Программирование декораторов классов............................... Непосредственное управление функциями и классами............ Пример: «частные» и «общедоступные» атрибуты.................. Пример: проверка аргументов функций................................ В заключение.................................................................... Закрепление пройденного................................................... 1087 1090 1100 1116 1127 1130 1142 1155 1156 Глава 39. Метаклассы........................................................... 1160 Нужны или не нужны метаклассы....................................... Модель метаклассов........................................................... Объявление метаклассов..................................................... Программирование метаклассов.......................................... Пример: добавление методов в классы.................................. Пример: применение декораторов к методам......................... В заключение.................................................................... Закрепление пройденного................................................... 1161 1168 1172 1173 1179 1186 1194 1195
16 Оглавление Часть IX. Приложения............................................................ 1197 Приложение A. Установка и настройка.................................. 1199 Установка интерпретатора Python........................................ Настройка Python.............................................................. Параметры командной строки интерпретатора....................... Дополнительная информация.............................................. 1199 1203 1208 1209 Приложение B. Решения упражнений................................... 1211 Часть I. Введение............................................................... Часть II. Типы и операции. ................................................. Часть III. Инструкции и синтаксис....................................... Часть IV. Функции............................................................ Часть V. Модули................................................................ Часть VI. Классы и ООП...................................................... Часть VII. Исключения и инструменты................................. 1211 1214 1219 1221 1229 1233 1241 Алфавитный указатель........................................................ 1249
Предисловие Эта книга представляет собой введение в ��������������������������������� Python��������������������������� – популярный язык программирования, используемый как для разработки самостоятельных программ, так и для создания прикладных сценариев в самых разных областях применения. Это мощный, переносимый, простой в использовании и свободно распространяемый язык. Программисты, работающие в самых разных областях, считают, что ориентация Python на эффективность разработки и высокое качество программного обеспечения дает ему стратегическое преимущество как в маленьких, так и в крупных проектах. Цель этой книги – помочь вам быстро овладеть основными принципами ��� Python���������������������������������������������������������������������� независимо от уровня вашей подготовки. Прочитав эту книгу, вы получите объем знаний, достаточный для использования этого языка. Издание задумывалось как учебник, основное внимание в котором уделяется ядру языка программирования Python, а не прикладным аспектам его использования. Вообще, эта книга должна рассматриваться как первая из следующего цикла: •• «Изучаем Python» – эта книга служит учебником по языку Python. •• «Программирование на Python»1, где помимо всего прочего показаны возможности применения языка Python после того, как он был освоен. То есть издания, посвященные прикладным аспектам, такие как «Программирование на Python», начинаются с того места, где заканчивается эта книга, и исследуют применение Python в различных прикладных областях, таких как веб-приложения, графические интерфейсы пользователя (ГИП) и приложения баз данных. Кроме того, в книге «������������������������������������� Python������������������������������� Pocket������������������������ ������������������������������ Reference�������������� ����������������������� », которая задумывалась как дополнение к этой книге, вы найдете дополнительные справочные материалы, не вошедшие в эту книгу. Благодаря такой направленности в этой книге стало возможным представить основы языка ������������������������������������������������������������� Python������������������������������������������������������� более глубоко, чем во многих других пособиях для начинающих. Книга основана на материалах практических курсов, включает в себя контрольные вопросы и самостоятельные упражнения и поэтому может служить введением в язык, рассчитанным на индивидуальную скорость освоения. О четвертом издании Четвертое издание книги претерпело три основных изменения: 1 Лутц М. «Программирование на Python», 2-е изд. – Пер. с англ. – СПб.: СимволПлюс, 2002. Четвертое издание этой книги выйдет в 2011 году.
18 Предисловие •• Охватываются обе версии, Python 3.0 и Python 2.6, с особым вниманием к версии 3.0, но при этом отмечаются отличия, имеющиеся в версии 2.6. •• Добавлено несколько новых глав, в основном посвященных развитию базовых возможностей языка. •• Проведена реорганизация части имевшегося материала и добавлены новые примеры для большей ясности. Когда я работал над этим изданием в 2009 году, существовало две основных версии интерпретатора Python – версия 3.0, представляющая новую ступень развития языка и несовместимая с прежним программным кодом, и версия 2.6, сохранившая обратную совместимость с огромным количеством существующих программ на языке Python. Хотя Python 3 рассматривается как будущее языка ���������������������������������������������������������� Python���������������������������������������������������� , тем не менее ������������������������������������� Python������������������������������� 2 по-прежнему широко используется и будет поддерживаться параллельно с ������������������������������ Python������������������������ 3 еще на протяжении нескольких лет. Версия 3.0 – это в значительной степени тот же язык программирования, однако она практически несовместима с программным кодом, написанным для прежних версий интерпретатора (тот факт, что инструкция print превратилась в функцию, только на первый взгляд кажется косметическим изменением, однако именно это обстоятельство сделало неработоспособными почти все программы на языке Python, написанные ранее). Наличие двух параллельно существующих версий представляет дилемму – как для программистов, так и для авторов книг. Проще всего было бы сделать вид, что версия ������������������������������������������������������������ Python������������������������������������������������������ 2 никогда не существовала, и сосредоточить все внимание только на версии 3, но это не будет отвечать потребностям большого количества пользователей языка Python. В настоящее время существует огромное количество программ, написанных для версии Python 2, и в ближайшее время они никуда не денутся. Начинающие программисты могут сосредоточиться на версии ������������������������������������������������������������������ Python������������������������������������������������������������ 3, но все, кому приходится сопровождать программы, написанные ранее, вынуждены одной ногой оставаться в Python 2. Для переноса всех сторонних библиотек и расширений на версию Python 3 могут потребоваться годы, поэтому такое раздвоение не будет преодолено в ближайшее время. Охват обеих версий, 3.0 и 2.6 Чтобы учесть это раздвоение и удовлетворить нужды всех потенциальных читателей, в этом издании рассматриваются обе версии, Python 3.0 и Python 2.6 (а также более поздние версии веток 3.X и 2.X). Эта книга предназначена для программистов, использующих ���������������������������������������������� Python���������������������������������������� 2, Python������������������������������ ������������������������������������ 3, а также для тех, кто пользуется обеими версиями, т. е. с помощью этой книги вы сможете изучить любую из основных версий языка Python. Основное внимание уделяется версии 3.0, тем не менее по ходу повествования будут отмечаться отличия, существующие в версии 2.6, и инструменты для тех, кому приходится сопровождать старые программы. Синтаксис языка программирования почти не изменился, однако имеется несколько важных отличий, о которых я также буду рассказывать по ходу изложения материала. Например, в большинстве примеров используется вызов функции print в стиле версии 3.0, но при этом будет описываться использование инструкции print, присутствующей в версии 2.6, чтобы вы могли понимать программный код, написанный ранее. Кроме того, я представлю новые особенности языка, такие как инструкция nonlocal, появившаяся в версии 3.0, и метод форматирования
19 Предисловие строк format в версиях 2.6 и 3.0, а также укажу, какие расширения отсутствуют в более старых версиях Python. Если вы только приступаете к изучению языка Python������������������������ ������������������������������ и не стоите перед необходимостью использовать устаревший программный код, я рекомендую начинать сразу с версии Python������������������������������������������������� ������������������������������������������������������� 3.0; в этой версии были устранены многие давнишние недостатки языка, при этом было сохранено все самое лучшее и добавлены некоторые новые возможности. К тому времени, когда вы будете читать эти строки, многие популярные биб­ лиотеки и инструменты наверняка станут доступны и в версии Python 3.0, особенно если учесть улучшение производительности операций ввода-вывода, которое заявлено в ожидающейся версии 3.1. Если вы используете программы, основанные на версии Python 2.X, вы обнаружите, что эта книга отвечает вашим потребностям в настоящее время, а в дальнейшем поможет вам выполнить переход на версию 3.0. По большей части это издание книги может использоваться для изучения языка Python при использовании разных выпусков версий Python 2 и 3, однако некоторые устаревшие версии интерпретатора из ветки 2.X могут оказаться не в состоянии выполнить программный код всех примеров, которые приводятся здесь. Например, декораторы классов могут использоваться в обеих версиях Python�������������������������������������������������������������������� 2.6 и 3.0, но вы не сможете применять их в более старых версиях ��� Python�������������������������������������������������������������������������� 2.����������������������������������������������������������������������� X���������������������������������������������������������������������� , где эта особенность языка отсутствует. Ниже, в табл. П.1 и П.2, приводятся основные отличия между версиями 2.6 и 3.0. Незадолго до передачи книги в печать она была дополнена примечаниями о наиболее существенных расширениях языка, по­ явившихся в версии Python 3.1: использование запятых в качестве разделителей и автоматическая нумерация полей в вызовах строкового метода format, синтаксис множественных менеджеров контекста в инструкциях with, новые методы чисел и так далее. Основная цель версии Python 3.1 – оптимизация скорости выполнения, поэтому данная книга также охватывает и эту новую версию. Фактически версия Python 3.1 выпускается как замена версии 3.0. Кроме того, последняя версия Python обычно всегда самая лучшая. Поэтому в этой книге термин «Python 3.0» практически везде используется для обозначения не конкретной версии, а изменений в языке, введенных в версии Python 3.0 и присутствующих во всех версиях ветки 3.X. Новые главы Основная цель этого издания – обновить примеры и сведения, приводившиеся в предыдущем издании и касающиеся версий Python 3.0 и 2.6. Кроме того, я добавил пять новых глав, описывающих новые особенности: •• Глава 27 – новое руководство по классам, где приведен более реалистичный пример, демонстрирующий основы объектно-ориентированного программирования (ООП) на языке Python. •• Глава 36 подробно рассказывает о строках Юникода и строках байтов, а также описывает отличия строк и файлов в версиях 3.0 и 2.6.
20 Предисловие •• Глава 37 описывает средства управления атрибутами, такие как свойства, и содержит новые сведения о дескрипторах. •• Глава 38 представляет декораторы функций и классов и содержит подробные и исчерпывающие примеры. •• Глава 39 охватывает метаклассы и сравнивает их с декораторами. Первая из этих глав представляет собой подробное пошаговое руководство по использованию классов и приемов ООП в языке ���������������������������� Python���������������������� . Она основана на примерах, используемых на учебных курсах и адаптированных для книги. Эта глава призвана продемонстрировать применение ООП в более приближенном к реальности контексте, чем в предыдущих изданиях, и показать, как может использоваться концепция классов для построения крупных программ. Я надеюсь, что эти примеры будут полезны настолько же, насколько они полезны на учебных курсах. Последние четыре главы в этом списке составляют заключительную часть книги «Расширенные возможности». С технической точки зрения эти темы относятся к основам языка программирования, тем не менее многие программисты используют простые строки символов ASCII и не нуждаются в детальном изучении строк Юникода и строк с двоичными данными. Точно так же декораторы и метаклассы являются узкоспециализированными темами, представляющими интерес скорее для разработчиков программных интерфейсов, чем для прикладных программистов. Поэтому эти четыре главы были выделены в отдельную часть и не являются обязательными для чтения. Если же вы используете эти возможности или сопровождаете программы, в которых они применяются, эти новые главы должны помочь вам освоить их. Кроме того, примеры в этих главах соединяют разнообразные базовые концепции языка и имеют большое практическое значение. В конце каждой главы имеются контрольные вопросы, но отсутствуют упражнения, так как эта часть не является обязательной для прочтения. Изменения в существующем материале Помимо всего прочего была проведена реорганизация материала предыдущего издания, добавлены новые примеры. Так, в главе 30 в описание механизма множественного наследования был включен новый пример вывода деревьев классов; в главу 20 были добавлены новые примеры использования генераторов для реализации собственных версий функций map и zip; в главу 31 были включены новые примеры, иллюстрирующие статические методы и методы классов; в главе 23 демонстрируется операция импортирования относительно пакета, а в главу 29 были добавлены примеры, иллюстрирующие методы __ contains__, __bool__ и __index__ перегрузки операторов и использование нового протокола перегрузки для операций извлечения среза и сравнения. Дополнительно была проведена реорганизация материала с целью добиться более последовательного изложения. Например, чтобы добавить новые сведения и избежать перегруженности, каждая из пяти вышеупомянутых глав была разбита на две главы. В результате появились новые самостоятельные главы, посвященные перегрузке операторов, областям видимости и аргументам, особенностям обработки исключений, а также генераторам и итераторам. Был немного изменен порядок следования существующих глав, чтобы обеспечить более последовательное освещение тем.
21 Предисловие В этом издании также была предпринята попытка ликвидировать ссылки на будущие темы за счет переупорядочения глав, однако в некоторых случаях это оказалось невозможным из-за изменений в ������������������������������� Python������������������������� 3.0: для полного понимания особенностей вывода строк и метода format вам потребуется знакомство с именованными аргументами функций; чтобы понять, как получить список ключей словаря и как проверить наличие того или иного ключа, необходимо знакомство с итераторами; чтобы научиться использовать функцию exec для выполнения программного кода, необходимо уметь применять объекты файлов, и так далее. Читать книгу по-прежнему предпочтительнее по порядку, однако иногда может потребоваться забежать вперед. В общей сложности в этом издании было выполнено несколько сотен изменений. Одни только таблицы в следующем разделе описывают 27 дополнений и 57 изменений в языке Python. Справедливости ради следует отметить, что это издание стало более продвинутым, потому что сам язык Python стал более продвинутым. Расширения языка, появившиеся в версиях 2.6 и 3.0 Вообще говоря, Python версии 3.0 стал более цельным, но он также стал в некотором роде и более сложным. На первый взгляд некоторые из изменений предполагают, что для изучения языка Python вы уже должны быть знакомы с ним! В предыдущем разделе уже были упомянуты некоторые темы, которые связаны круговой зависимостью в версии 3.0, например объяснение темы представлений словарей практически невозможно без наличия предварительных знаний. Помимо обучения основам языка ��������������������������������� Python��������������������������� эта книга послужит подспорьем в заполнении подобных пробелов в ваших представлениях. В табл. П.1 перечислены наиболее заметные новые особенности языка и номера глав, в которых они описываются. Таблица П.1. Нововведения в версиях Python 2.6 и 3.0 Нововведение См. главы Функция print в версии 3.0 11 Инструкция nonlocal в версии 3.0 17 Метод str.format в версиях 2.6 и 3.0 7 Строковые типы в версии 3.0: str – для представления строк Юникода, bytes – для представления двоичных данных 7, 36 Отличия между текстовыми и двоичными файлами в версии 3.0 9, 36 Декораторы классов в версиях 2.6 и 3.0: @private(‘age’) 31, 38 Новые итераторы в версии 3.0: range, map, zip 14, 20 Представления словарей в версии 3.0: D.keys, D.values, D.items 8, 14 Операторы деления в версии 3.0: остаток, / и // 5
22 Предисловие Таблица П.1 (продолжение) Нововведение См. главы Литералы множеств в версии 3.0: {a, b, c} 5 Генераторы множеств в версии 3.0: {x**2 for x in seq} 4, 5, 14, 20 Генераторы словарей в версии 3.0: {x: x**2 for x in seq} 4, 5, 14, 20 Поддержка представления двоичных чисел в виде строк в версиях 2.6 и 3.0: 0b0101, bin(I) 5 Тип представления рациональных чисел в версиях 2.6 и 3.0: Fraction(1, 3) 5 Аннотации функций в версии 3.0: def f(a:99, b:str)->int 19 Аргументы, которые могут быть только именованными в версии 3.0: def f(a, *b, c, **d) 18, 20 Расширенная операция распаковывания последовательностей в версии 3.0: a, *b = seq 11, 13 Синтаксис импортирования относительно пакета в версии 3.0: from . 23 Менеджеры контекста в версиях 2.6 и 3.0: with/as 33, 35 Синтаксис исключений в версии 3.0: raise, except/as, суперклассы 33, 34 Объединение исключений в цепочки в версии 3.0: raise e2 from e1 33 Изменения в наборе зарезервированных слов в версиях 2.6 и 3.0 11 Переход на использование классов «нового стиля» в версии 3.0 31 Декораторы свойств в версиях 2.6 и 3.0: @property 37 Дескрипторы в версиях 2.6 и 3.0 31, 38 Метаклассы в версиях 2.6 и 3.0 31, 39 Поддержка абстрактных базовых классов в версиях 2.6 и 3.0 28 Особенности языка, удаленные в версии 3.0 Помимо дополнений в версии 3.0 некоторые особенности языка были удалены с целью сделать его синтаксис более стройным. В табл. П.2 перечислены изменения, которые были учтены в различных главах этого издания. Для многих особенностей, перечисленных в табл. П.2, имеются прямые замены, часть из которых также доступна в версии 2.6, чтобы обеспечить поддержку перехода на версию 3.0.
23 Предисловие Таблица П.2. Особенности языка, удаленные в версии Python 3.0, которые были учтены в этой книге Удаленная особенность Замена См. главы reload(M) imp.reload(M) (или exec) 3, 22 apply(f, ps, ks) f(*ps, **ks) 18 `X` repr(X) 5 X <> Y X != Y 5 long int 5 9999L 9999 5 D.has_key(K) K in D (или D.get(key) != None) 8 raw_input input 3, 10 прежняя версия input eval(input) 3 xrange range 14 file open (и классы из модуля io) 9 X.next X.__next__, вызывается функцией next(X) 14, 20, 29 X.__getslice__ Методу X.__getitem__ передается объект среза 7, 29 X.__setslice__ Методу X.__setitem__ передается объект среза 7, 29 reduce functools.reduce (или реализация цикла вручную) 14, 19 execfile(filename) exec(open(filename).read()) 3 exec open(filename) exec(open(filename).read()) 3 0777 0o777 5 print x, y print(x, y) 11 print >> F, x, y print(x, y, file=F) 11 print x, y, print(x, y, end=’ ‘) 11 u’ccc’ ‘ccc’ 7, 36 ‘bbb’ для строк байтов b’bbb’ 7, 9, 36 raise E, V raise E(V) 32, 33, 34 except E, X: except E as X: 32, 33, 34 def f((a, b)): def f(x): (a, b) = x 11, 18, 20 file.xreadlines for line in file: (или X=iter(file)) 13, 14 D.keys и др., результат в виде списка list(D.keys) (представления словарей) 8, 14
24 Предисловие Таблица П.2 (продолжение) Удаленная особенность Замена См. главы map, range и др., результат в виде списка list(map()), list(range()) (встроенная функция) 14 map(None, ...) zip (или дополнение результатов вручную) 13, 20 X=D.keys(); X.sort() sorted(D) (или list(D.keys())) 4, 8, 14 cmp(x, y) (x > y) - (x < y) 29 X.__cmp__(y) __lt__, __gt__, __eq__ и т. д. 29 X.__nonzero__ X.__bool__ 29 X.__hex__, X.__oct__ X.__index__ 29 Различные функции сортировки Используются аргументы key=transform и reverse=True 8 Операции над словарями Сравнивание sorted(D.items()) <, >, <=, >= (или реализация цикла вручную) 8, 9 types.ListType list (только для невстроенных типов) 9 __metaclass__ = M class C(metaclass=M): 28, 31, 39 __builtin__ builtins (переименован) 17 Tkinter tkinter (переименован) 18, 19, 24, 29, 30 sys.exc_type, exc_value sys.exc_info()[0], [1] 34, 35 function.func_code function.__code__ 19, 38 __getattr__ вызывается Переопределение методов __X__ встроенными функциями в классе-обертке 30, 37, 38 -t, –tt ключи командной строки Чередование использования символов 10,12 табуляции и пробелов всегда приводит к ошибке from ... *, внутри функции Может использоваться только на верхнем уровне в модуле import mod, из модуля в том же пакете from . import mod, импортирование от- 23 носительно пакета class MyException: class MyException(Exception): 34 Модуль exceptions Встроенная область видимости, справочное руководство по библиотеке 34 Модули thread, Queue _thread, queue (переименованы) 17 Модуль anydbm dbm (переименован) 27 Модуль cPickle _pickle (переименован, используется автоматически) 9 22
25 Предисловие Удаленная особенность Замена См. главы os.popen2/3/4 subprocess.Popen (os.popen по-прежнему поддерживается) 14 Исключения на базе строк Исключения на базе классов (обязательны в версии 2.6) 32, 33, 34 Модуль с функциями для Методы объектов строк работы со строками 7 Несвязанные методы 30, 31 Функции (staticmethod – для вызова относительно экземпляра) Смешивание несовмести- Смешивание несовместимых типов мых типов в операциях в операциях сравнения вызывает посравнения и сортировки явление ошибки 5, 9 В Python 3.0 имеются изменения, которые не были включены в эту таблицу, т. к. они не относятся к кругу тем этой книги. Например, изменения в стандартной библиотеке представляют больший интерес для книг, освещающих прикладные аспекты применения языка, таких как «Программирование на Python», чем для этой книги. Хотя стандартная библиотека в значительной степени поддерживает прежнюю функциональность, в Python 3.0 некоторые модули были переименованы, сгруппированы в пакеты и так далее. Более полный список изменений, внесенных в версию 3.0, можно найти в документе «��������������������������������������������������������������������������� What����������������������������������������������������������������������� ’���������������������������������������������������������������������� s��������������������������������������������������������������������� �������������������������������������������������������������������� New����������������������������������������������������������������� ���������������������������������������������������������������� in�������������������������������������������������������������� ������������������������������������������������������������� Python������������������������������������������������������� 3.0» (Что нового в ����������������������������������� Python����������������������������� 3.0), включенном в стандартный набор справочных руководств.1 При переходе с версии ����������������������������������������������������� Python����������������������������������������������� 2.�������������������������������������������� X������������������������������������������� на версию Python�������������������������� �������������������������������� 3.����������������������� X���������������������� обязательно ознакомьтесь со сценарием 2to3 автоматического переноса программного кода, который входит в состав дистрибутива Python��������������������������������������� ��������������������������������������������� 3.0. Конечно, он не гарантирует выполнение переноса любой программы, но способен преобразовать большую часть программного кода, написанного для ���������������������������������������� Python���������������������������������� 2.������������������������������� X,����������������������������� так, что он будет выполняться под управлением Python 3.X. К моменту написания этих строк на стадии реа­лизации находился проект сценария 3to2 для обратного преобразования программного кода, написанного для ������������������������������������ Python������������������������������ 3.��������������������������� X�������������������������� , так, чтобы он мог выполняться в среде Python 2.������������������������������������������������� X������������������������������������������������ . Любой из этих инструментов может оказаться полезным для тех, кому приходится сопровождать программы, которые должны выполняться под управлением обеих основных версий Python. Подробности об этих утилитах ищите в Интернете. О третьем издании Новая редакция отражает последние новшества, появившиеся в самом языке и в методиках его обучения. Помимо этого, была несколько изменена структура книги. 1 Аналогичную информацию (хотя это и не прямой перевод указанного документа) на русском языке можно найти на странице http://www.ibm.com/developerworks/ru/ library/l-python3-1/. – Примеч. перев.
26 Предисловие Изменения в языке Python (для 3-го издания) Если говорить о версии языка, это издание описывает Python 2.5 и отражает все изменения, появившиеся в языке с момента выхода второго издания книги в конце 2003 года. (Во втором издании описывался язык ���������������� Python���������� 2.2 и некоторые нововведения версии 2.3.) Кроме того, в этом издании обсуждаются изменения, которые ожидаются в версии Python 3.0. Ниже приводится список основных тем, касающихся языка программирования, которые вы найдете в этом издании (нумерация глав была изменена, чтобы соответствовать четвертому изданию): •• Новая условная конструкция B if A else C (глава 19) •• Оператор менеджера контекста with/as (глава 33) •• Унификация конструкции try/except/finally (глава 33) •• Синтаксис относительного импорта (глава 23) •• Выражения-генераторы (глава 20) •• Новые особенности функций-генераторов (глава 20) •• Функции-декораторы (глава 31) •• Объектный тип множества (глава 5) •• Новые встроенные функции: sorted, sum, any, all, enumerate (главы 13 и 14) •• Объектный тип десятичных чисел с фиксированной точностью представления (глава 5) •• Файлы, генераторы списков и итераторы (главы 14 и 20) •• Новые инструменты разработки: Eclipse, dustutils, unittest и doctest, расширения IDLE, Shedskin и так далее (главы 2 и 35) Менее значительные изменения в языке (такие как широко используемые значения True и False, новая функция sys.exec_info, которая возвращает подробную информацию об исключении, и отказ от строковых исключений, методы строк и встроенные функции apply и reduce) обсуждаются на протяжении всей книги. Кроме того, здесь приводится расширенное описание некоторых новых особенностей, впервые появившихся во втором издании, в том числе третье измерение при работе со срезами и возможность передачи функциям произвольного числа аргументов, включая функцию apply. Изменения в обучении языку Python (для 3-го издания) Кроме уже перечисленных изменений в самом языке, третье издание дополнено новыми темами и примерами, наработанными мною при преподавании на курсах обучения языку Python в последние годы. Например, здесь вы найдете (нумерация глав была изменена с целью соответствовать четвертому изданию): •• Новую главу о встроенных типах (глава 4) •• Новую главу о синтаксических конструкциях (глава 10) •• Полностью новую главу о динамической типизации с углубленным освещением этого вопроса (глава 6) •• Расширенное введение в ООП (глава 25) •• Новые примеры работы с файлами, областями видимости, вложенными инструкциями, классами, исключениями и так далее
Предисловие 27 Множество изменений и дополнений было сделано, чтобы облегчить чтение книги начинающим программистам; в результате обсуждение некоторых тем было перемещено в более соответствующие для этого места с учетом опыта преподавания ��������������������������������������������������������������� Python��������������������������������������������������������� на курсах. Например, описание генераторов списков и итераторов теперь приводится вместе с описанием оператора цикла for, а не с описанием функциональных инструментов, как это было ранее. Кроме того, в третьем издании было расширено описание основ языка, добавлены новые темы и примеры. Поскольку эта книга фактически превратилась в стандартный учебник по языку Python, изложение материала стало более полным и расширено новыми примерами его использования. Был полностью обновлен комплект советов и рекомендаций, подобранных из опыта преподавания в течение 10 лет и практического использования Python в течение 15 лет. Также были дополнены и расширены учебные упражнения с целью отразить наиболее удачные современные приемы программирования на языке ���������������������������������������������������������������� Python���������������������������������������������������������� , его новые особенности и показать наиболее типичные ошибки, которые совершают начинающие программисты на моих курсах. Вообще, основы языка в этом издании обсуждаются более широко, чем в предыдущих изданиях. Структурные изменения в 3-м издании Чтобы облегчить усвоение основ языка, весь материал поделен на несколько частей, каждая из которых содержит несколько глав. Например, типы и инструкции теперь описываются в двух разных частях, в каждой из которых основным типам и инструкциям отведены отдельные главы. При переработке материала упражнения и описания наиболее распространенных ошибок были перемещены из конца каждой главы в конец части. Каждая глава завершается кратким обзором и контрольными вопросами, которые помогут проверить, насколько хорошо понят изложенный материал. В отличие от упражнений в конце каждой части, решения для которых приводятся в приложении ����������������������������������������������������� B���������������������������������������������������� , ответы на вопросы в конце каждой главы следуют непосредственно за вопросами. Я рекомендую просматривать ответы, даже если вы уверены, что правильно ответили, потому что эти ответы, кроме прочего, являются кратким обзором только что пройденной темы. Несмотря на наличие новых тем, эта книга по-прежнему ориентирована на тех, кто только начинает знакомство с языком Python. Поскольку третье издание в значительной степени основано на проверенном временем опыте преподавания, оно, как и первые два, может служить вводным курсом для самостоятельного изучения языка Python. Ограничение области применения книги Третье издание представляет собой учебник по основам языка программирования Python��������������������������������������������������������������� ��������������������������������������������������������������������� и ничего больше. Здесь приводятся всесторонние сведения о языке, которые необходимо знать, прежде чем приступать к практическому его использованию. Материал подается в порядке постепенного усложнения и дает полное представление о языке программирования, не фокусируясь на областях его применения. Для некоторых «изучить Python» означает потратить час-другой на изучение руководств в Интернете. Такой подход пригоден для опытных программи-
28 Предисловие стов – в конце концов, Python – довольно простой язык по сравнению с другими языками программирования. Однако проблема такого ускоренного изучения состоит в том, что на практике программисты часто сталкиваются с необычными случаями необъяснимого изменения значений переменных, параметров по умолчанию и так далее. Цель этой книги – дать твердое понимание основ языка Python, чтобы даже самые необычные случаи находили свое объяснение и чтобы вы смогли применять его для решения прикладных задач независимо от предметной области, в которой работаете. Это ограничение было введено намеренно. Ограничившись обсуждением основ языка, мы можем заняться более глубоким и полным их исследованием. Обсуждение темы прикладного использования Python и справочные материалы, не вошедшие в эту книгу, вы найдете в других публикациях, которые начинаются с того места, где заканчивается эта книга. О книге «Изучаем Python» В этом разделе приводятся некоторые наиболее важные замечания об этой книге независимо от номера издания. Никакая книга не способна удовлетворить все нужды и потребности читателя, поэтому важно понимать основные цели книги. Предварительные условия В действительности книга не предъявляет никаких предварительных условий. Она с успехом использовалась как начинающими программистами, так и умуд­ренными опытом ветеранами. Если у вас есть желание изучать Python, эта книга наверняка вам поможет. Наличие у читателя некоторого опыта в программировании не является обязательным, но будет совсем не лишним. Эта книга задумывалась как введение в Python для программистов.1 Возможно, она не идеальна для тех, кто раньше никогда не имел дела с компьютерами (например, мы не будем объяснять, что такое компьютер), но я не делал никаких предположений о наличии у читателя опыта программирования или об уровне его подготовки. С другой стороны, я не считаю нужным обижать читателей, предполагая, что они «чайники», что бы это ни означало, – писать полезные программы на языке Python просто, и эта книга покажет, как это делается. В книге Python иногда противопоставляется другим языкам программирования, таким как C, C++, Java и Pascal, но эти сравнения можно просто игнорировать, если ранее вам не приходилось работать с этими языками. Сравнение с другими книгами Эта книга охватывает все основные аспекты языка программирования Python, но при этом я старался ограничить круг обсуждаемых тем, чтобы уменьшить 1 Под «программистами» я подразумеваю всех, кто написал хотя бы одну строчку кода на любом языке программирования. Если вы не входите в эту категорию, вы все равно сможете извлечь пользу из этой книги, но имейте в виду, что основное внимание в ней уделяется не основным принципам программирования, а изучению основ языка программирования Python.
Предисловие 29 объем книги. Для сохранения простоты в ней рассматриваются самые основные понятия, используются небольшие и очевидные примеры и опущены некоторые незначительные детали, которые вы найдете в справочных руководствах. По этой причине данная книга должна рассматриваться как введение, как первый шаг к другим, более специализированным и более полным книгам. Например, мы не будем говорить об интеграции Python/C; это слишком сложная тема, которая, однако, является центральной для многих систем, основанных на применении Python. Мы также не будем говорить об истории развития Python и о процессе его разработки. А таких популярных применений Python, как создание графического интерфейса, разработка системных инструментов и работа с сетью, мы коснемся лишь очень кратко, если они вообще будут упоминаться. Естественно, при таком подходе из поля зрения выпадает значительная часть общей картины. Вообще говоря, Python стоит на более высоком качественном уровне относительно других языков сценариев. Некоторые из его идей требуют более глубокого изучения, чем может вместить эта книга, поэтому я надеюсь, что большинство читателей продолжит изучение принципов разработки приложений на этом языке, обратившись к другим источникам информации. Например, книга «Программирование на Python»1 (O’Reilly), содержащая более объемные и полные примеры наряду с описанием приемов прикладного программирования, задумывалась как продолжение книги «Изучаем Python». Эти две книги представляют собой две части курса обучения, который преподает автор, – основы языка и прикладное программирование. Кроме того, в качестве справочника можно использовать «Pyton Pocket Reference» (O’Reilly), где приводятся некоторые подробности, опущенные здесь. Для дальнейшего изучения можно порекомендовать книги, содержащие дополнительные сведения, примеры или особенности использования языка Python в определенных прикладных областях, таких как веб-приложения и создание графических интерфейсов. Например, книги «Python in a Nutshell» (O’Relly) и «Python Essential Reference»2 (Sams) содержат справочную информацию. Книга «Python Cookbook» (O’Reilly) представляет собой сборник решений для тех, кто уже знаком с приемами прикладного программирования. Поскольку выбор книг является делом достаточно субъективным, я рекомендую вам самостоятельно поискать такие, которые наиболее полно будут отвечать вашим потребностям. Неважно, какие книги вы выберете, главное – помните, что для дальнейшего изучения Python вам необходимы более реалистичные примеры, чем приводятся здесь. На мой взгляд, данная книга будет для вас отличным учебником нача