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

Марк Саммерфилд

Python 
на практике

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

Upper Saddle River, NJ · Boston · Indianapolis · San Francisco

New York · Toronto · Montreal · London · Munich · Paris · Madrid

Capetown · Sydney · Tokyo · Singapore · Mexico City

Python in Practice

Create Better Programs Using  
Concurrency, Libraries,  
and Patterns

Mark Summerfield

Ìîñêâà, 2023

Python на практике

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

Марк Саммерфилд

 2-å èçäàíèå, ýëåêòðîííîå

УДК 004.3’144:004.383.5Python
ББК 32.973.26-04
С17

С17
Саммерфилд, Марк.
Python на практике. Создание качественных программ с использованием 
параллелизма, библиотек и паттернов / М. Саммерфильд ; пер. с англ. 
А. А. Слинкина. — 2-е изд., эл. — 1 файл pdf : 340 с. — Москва : ДМК Пресс, 
2023. — Систем. требования: Adobe Reader XI либо Adobe Digital Editions 
4.5 ; экран 10". — Текст : электронный.
ISBN 978-5-89818-322-6
Если вы — опытный программист на Python, то после прочтения данной книги 
ваши программы станут более качественными, надежными, быстрыми, удобными 
для сопровождения и использования.
В центре внимания Марка Саммерфилда находятся четыре основных темы: 
повышение элегантности кода с помощью паттернов проектирования, повышения 
быстродействия с помощью распараллеливания и компиляции Python-программ 
(Cython), высокоуровневое сетевое программирование и графика. Он описывает 
паттерны, доказавшие свою полезность в Python, иллюстрирует их на примерах 
высококачественного кода и объясняет, почему некоторые из них не слишком существенны.

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

УДК 004.3’144:004.383.5Python 
ББК 32.973.26-04

Электронное издание на основе печатного издания: Python на практике. Создание качественных 
программ с использованием параллелизма, библиотек и паттернов / М. Саммерфильд ; 
пер. с англ. А. А. Слинкина. — Москва : ДМК Пресс, 2014. — 338 с. — ISBN 978-5-97060-095-
5. — Текст : непосредственный.

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

В соответствии со ст. 1299 и 1301 ГК РФ при устранении ограничений, установленных техническими средствами 
защиты авторских прав, правообладатель вправе требовать от нарушителя возмещения убытков или выплаты компенсации.


ISBN 978-5-89818-322-6
© 2014 Qtrac Ltd.
©  Оформление, перевод на русский язык, 
издание ДМК Пресс, 2014

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

ОГЛАВЛЕНИЕ

Предисловие .....................................................9
Введение ........................................................ 11
Благодарности ........................................................................ 14

Глава 1. Порождающие паттерны проектирования 
в Python .......................................................... 16
1.1. Паттерн Абстрактная фабрика .......................................... 16
1.1.1. Классическая Абстрактная фабрика .................................. 17
1.1.2. Абстрактная фабрика в духе Python................................... 20
1.2. Паттерн Построитель ........................................................ 22
1.3. Паттерн Фабричный метод ................................................ 28
1.4. Паттерн Прототип ............................................................. 37
1.5. Паттерн Одиночка ............................................................. 38

Глава 2. Структурные паттерны проектирования 
в Python .......................................................... 40
2.1. Паттерн Адаптер ............................................................... 40
2.2. Паттерн Мост .................................................................... 46
2.3. Паттерн Компоновщик ...................................................... 52
2.3.1. Классическая иерархия составных и несоставных 
объектов .................................................................................... 53
2.3.2. Единый класс для составных и несоставных объектов ....... 57
2.4. Паттерн Декоратор ........................................................... 60
2.4.1. Декораторы функций и методов ........................................ 61
2.4.2. Декораторы классов ......................................................... 67
2.5. Паттерн Фасад .................................................................. 74
2.6. Паттерн Приспособленец ................................................. 79
2.7. Паттерн Заместитель ........................................................ 82

Глава 3. Поведенческие паттерны проектирования 
в Python .......................................................... 88
3.1. Паттерн Цепочка ответственности .................................... 88
3.1.1. Традиционная Цепочка ..................................................... 89
3.1.2. Цепочка на основе сопрограмм ........................................ 91
3.2. Паттерн Команда .............................................................. 95

Оглавление

3.3. Паттерн Интерпретатор .................................................... 99
3.3.1. Вычисление выражения с помощью eval() ....................... 100
3.3.2. Исполнение кода с помощью exec() ................................ 104
3.3.3. Исполнение кода в подпроцессе ..................................... 107
3.4. Паттерн Итератор ........................................................... 112
3.4.1. Итераторы, следующие протоколу 
последовательности ................................................................ 112
3.4.2. Реализация итераторов с помощью функции iter() 
с двумя аргументами ................................................................ 113
3.4.3. Итераторы на базе протокола итераторов ...................... 115
3.5. Паттерн Посредник ......................................................... 118
3.5.1. Традиционный Посредник ............................................... 119
3.5.2. Посредник на основе сопрограмм .................................. 123
3.6. Паттерн Хранитель .......................................................... 125
3.7. Паттерн Наблюдатель ..................................................... 125
3.8. Паттерн Состояние ......................................................... 130
3.8.1. Чувствительные к состоянию методы .............................. 133
3.8.2. Определяемые состоянием методы ................................ 135
3.9. Паттерн Стратегия .......................................................... 136
3.10. Паттерн Шаблонный метод ........................................... 139
3.11. Паттерн Посетитель ...................................................... 142
3.12. Пример: пакет обработки изображений ........................ 144
3.12.1. Общий модуль обработки изображений ........................ 146
3.12.2. Обзор модуля Xpm ........................................................ 156
3.12.3. Модуль-обертка PNG .................................................... 159

Глава 4.Высокоуровневый параллелизм в Python ... 162
4.1. Распараллеливание задач с большим объемом 
вычислений ........................................................................... 166
4.1.1. Очереди и многопроцессная обработка .......................... 169
4.1.2. Будущие объекты и многопроцессная обработка ............ 175
4.2. Распараллеливание задач, ограниченных скоростью 
ввода-вывода ........................................................................ 178
4.2.1. Очереди и многопоточность ........................................... 180
4.2.2. Будущие объекты и многопоточность.............................. 185
4.3. Пример: приложение с параллельным ГИП ..................... 188
4.3.1. Создание ГИП ................................................................. 190
4.3.2. Модуль ImageScaleWorker ............................................... 198
4.3.3. Как ГИП обрабатывает продвижение .............................. 201
4.3.4. Как ГИП обрабатывает выход из программы ................... 203

Глава 5. Расширение Python ............................. 205
5.1. Доступ к написанным на C библиотекам с помощью 
пакета ctypes ......................................................................... 207

Оглавление

5.2. Использование Cython .................................................... 215
5.2.1. Доступ к написанным на C библиотекам 
с помощью Cython .................................................................... 215
5.2.2. Создание Cython-модулей для повышения 
производительности ................................................................ 222
5.3. Пример: ускоренная версия пакета Image ....................... 228

Глава 6. Высокоуровневое сетевое 
программирование на Python ........................... 233
6.1. Создание приложений на базе технологии XML-RPC ....... 234
6.1.1. Обертка данных .............................................................. 235
6.1.2. Разработка сервера XML-RPC ......................................... 239
6.1.3. Разработка клиента XML-RPC ......................................... 241
6.2. Создание приложений на базе технологии RPyC ............. 251
6.2.1. Потокобезопасная обертка данных ................................. 251
6.2.2. Разработка сервера RPyC ............................................... 257
6.2.3. Разработка клиента RPyC ............................................... 260

Глава 7. Графические интерфейсы пользователя 
на Python и Tkinter .......................................... 264
7.1. Введение в Tkinter ........................................................... 267
7.2. Создание диалоговых окон с помощью Tkinter ................ 269
7.2.1. Создание диалогового приложения ................................ 271
7.2.2. Создание диалоговых окон в приложении ....................... 280
7.3. Создание приложений с главным окном 
с помощью Tkinter ................................................................. 290
7.3.1. Создание главного окна .................................................. 292
7.3.2. Создание меню ............................................................... 294
7.3.3. Создание строки состояния с индикаторами .................. 297

Глава 8. Трехмерная графика на Python 
с применением OpenGL ................................... 301
8.1. Сцена в перспективной проекции ................................... 303
8.1.1. Создание программы Cylinder с помощью PyOpenGL ...... 304
8.1.2. Создание программы Cylinder с помощью pyglet ............. 309
8.2. Игра в ортографической проекции .................................. 311
8.2.1. Рисование сцены с доской .............................................. 314
8.2.2. Обработка выбора объекта на сцене ............................... 317
8.2.3. Обработка взаимодействия с пользователем ................. 319

Приложение A. Эпилог..................................... 323
Приложение B. Краткая библиография ............... 325
Предметный указатель .................................... 329

ПРЕДИСЛОВИЕ

Вот уже 15 лет как я пишу программы в разных областях на Python. 
Я видел, как сообщество росло и становилось более зрелым. Давно 
миновали те дни, когда нам приходилось «продавать» Python менеджерам, 
чтобы получить возможность использовать его в работе. 
Сегодня на программистов, пишущих на Python, большой спрос. На 
конференциях по Python всегда не протолкнуться, причем это относится 
не только к крупным национальным и международным мероприятиям, 
но и к местным собраниям. Благодаря проектам типа 
OpenStack язык захватывает новые территории, привлекая попутно 
новые таланты. Располагая здоровым и расширяющимся сообществом, 
мы теперь можем рассчитывать на более интересные и качественные 
книги о Python.
Марк Саммерфилд хорошо известен сообществу Python своими 
техническими текстами о Qt и Python. Книга Марка «Программирование 
на Python 3» занимает верхнее место в списке моих рекомендаций 
всем изучающим Python. Так я и отвечаю, когда мне как организатору 
группы пользователей в Атланте, штат Джорджия, задают 
этот вопрос. Эта книга тоже попадет в мой список, но для другой аудитории.

Большинство книг по программированию попадают в один из двух 
концов довольно широкого спектра, простирающегося от простого 
введения в язык (или программирование вообще) до более сложных 
книг, посвященных узкой теме, например, разработка веб-приложений, 
графические интерфейсы или биоинформатика. Работая над 
книгой «The Python Standard Library by Example», я рассчитывал на 
читателей, находящихся между этими крайностями, – сложившихся 
программистов-универсалов, которые знакомы с языком, но хотят отточить 
свои навыки  выйти за пределы основ, но не ограничиваться 
какой-то узкой прикладной областью. Когда редактор попросил меня 
дать отзыв на предложение книги Марка, я с радостью увидел, что он 
ориентировал «Python на практике» на тот же круг читателей.
Давно уже не встречал я в книгах идей, которые можно было бы 
сразу же применить в каком-то из моих собственных проектов, не 

Предисловие

привязываясь к конкретному каркасу или библиотеке. Последний 
год я работал над системой для измерения параметров облачных 
служб OpenStack. По ходу работы наша команда поняла, что данные, 
собираемые для выставления счетов, можно с пользой применить и 
для других целей, в том числе отчетности и мониторинга, поэтому мы 
спроектировали систему, которая рассылает их многим потребителям 
путем передачи выборок по конвейеру, составленному из повторно 
используемых трансформаций и издателей. Приблизительно одновременно 
с завершением кода конвейера я принялся писать техническую 
рецензию на эту книгу. Прочитав первые несколько разделов 
черновика главы 3, я понял, что наша реализация конвейера оказалась 
гораздо сложнее, чем нужно. Продемонстрированная Марком 
техника построения цепочки сопрограмм настолько элегантнее и 
проще для понимания, что я сразу же добавил в наш план задачу по 
перепроектированию в цикл подготовки следующей версии.
Книга «Python на практике» полна таких полезных советов и примеров 
так что вам будет чему поучиться. Универсалы вроде меня 
смогут познакомиться с некоторыми интересными инструментами, 
с которыми раньше не сталкивались. И будь вы опытным программистом 
или только-только вышедшим из начальной стадии карьеры, 
эта книга поможет взглянуть на проблему с разных точек зрения и 
подскажет, как создавать более эффективные решения.

Дуг Хэллман
старший разработчик, DreamHost
май, 2013

ВВЕДЕНИЕ

Эта книга ориентирована на программистов, пишущих на Python, которые 
хотели бы расширить и углубить знания языка, чтобы сделать 
свои программы более качественными, надежными, быстрыми, удобными 
для сопровождения и использования. В этой книге много практических 
примеров и идей. Рассматриваются четыре основных темы: 
применение паттернов проектирования для создания более элегантного 
кода, ускорение обработки за счет использования параллелизма 
и компиляции Python-кода (Cython), высокоуровневое сетевое программирование 
и графика.
Книга «Design Patterns: Elements of Reusable Object-Oriented 
Software»1 (см. краткую библиографию) вышла еще в 1995 году, но по 
сей день оказывает огромное влияние на практическое объектно-ориентированное 
программирование. В книге «Python на практике» все 
паттерны проектирования рассмотрены в контексте языка Python – 
на примерах демонстрируется их полезность и объясняется, почему 
некоторые паттерны пишущим на Python неинтересны. Паттернам 
посвящены главы 1, 2 и 3.
Глобальная блокировка интерпретатора (GIL) в Python препятствует 
исполнению кода Python одновременно несколькими процессорными 
ядрами2. Отсюда пошел миф, будто программа на Python 
не может быть многопоточной и не способна воспользоваться преимуществами 
многоядерных процессоров. Но счетные задачи вполне 
можно распараллеливать с помощью модуля multiprocessing, который 
не связан ограничением GIL и может задействовать все имеющиеся 
ядра. При этом легко получить ожидаемое ускорение (примерно 
пропорциональное количеству ядер). Для программ, занятых 
преимущественно вводом-выводом, модуль multiprocessing тоже 

1 
 Эрих Гамма, Ричард Хелм, Ральф Джонсон, Джон Влиссидес «Приемы объектно-
ориентированного проектирования. Паттерны проектирования», ДМК Пресс, Питер, 
2013. – Прим. перев.
2 
 Это ограничение относится к CPython – эталонной реализации, которую использует 
большинство программистов. В некоторых реализациях Python такого ограничения 
нет, самой известной из них является Jython (Python, реализованный на Java).

Введение

можно использовать, а можно вместо этого обратиться к модулю 
threading или concurrent.futures. Если для распараллеливания 
таких программ используется модуль threading, то издержки GIL 
обычно маскируются сетевыми задержками, так что практического 
значения не имеют.
К сожалению, распараллеливание на низком и среднем уровне 
чревато ошибками (в любом языке). Этих проблем можно избежать, 
если воздержаться от явного использования блокировок, а работать 
с высокоуровневыми модулями queue и multiprocessing для реализации 
очередей или с модулем concurrent.futures. В главе 4 мы 
увидим, как с помощью высокоуровневого параллелизма достичь существенного 
повышения производительности.
Иногда программисты обращаются к C, C++ или другому компилируемому 
языку, поверив еще одному мифу – будто Python работает 
медленно. Да, вообще говоря, Python медленнее компилируемых 
языков, но при использовании современного оборудования его быстродействия 
более чем достаточно для большинства приложений. А в 
тех случаях, когда Python все-таки недостаточно шустр, мы все равно 
можем получать все преимущества от программирования на нем и 
при этом ускорить работу программы.
Для ускорения долго работающих программ можно использовать 
интерпретатор PyPy (pypy.org). Это JIT-компилятор, способный 
дать значительный выигрыш в скорости. Другой способ повысить 
производительность – пользоваться кодом, который работает со скоростью 
откомпилированного C; в счетных задачах так вполне можно 
добиться 100-кратного увеличения скорости. Получить такое быстродействие 
проще всего, воспользовавшись модулями Python, которые 
уже написаны на C, например, модулем array из стандартной библиотеки 
или сторонним модулем numpy, которые обеспечивают невероятно 
быструю и эффективную с точки зрения потребления памяти 
работу с массивами (в случае numpy – даже с многомерными). Другой 
вариант – выполнить профилирование программы с помощью модуля 
cProfi le  из стандартной библиотеки, найти узкие места и переписать 
критический в плане быстродействия код на Cython – это, по 
существу, вариант Python с расширенным синтаксисом, который компилируется 
в чистый C, что обеспечивает максимальную скорость во 
время выполнения.
Разумеется, иногда нужная функциональность уже имеется в какой-
нибудь библиотеке, написанной на C, C++ или другом языке с 
таким же соглашением о вызовах, как в C. В большинстве случаев уже 

Введение

имеется сторонний Python-модуль, реализующий интерфейс с этой 
библиотекой; его можно поискать в Указателе Python-пакетов (PyPI, 
pypi.python.org). Если же, что крайне маловероятно, такого модуля 
еще нет, то для доступа к функциям C-библиотеки можно воспользоваться 
модулем ctypes из стандартной библиотеки или сторонним 
пакетом Cython. Использование готовых C-библиотек заметно сокращает 
время разработки и обычно позволяет достичь очень высокой 
скорости работы. Cython и ctypes рассматриваются в главе 5.
В стандартной библиотеке Python есть много модулей для сетевого 
программирования, в том числе низкоуровневый модуль socket, 
модуль среднего уровня socketserver и высокоуровневый модуль 
xmlrpclib. Сетевое программирование на низком и среднем уровне 
оправдано при переносе кода с другого языка, но если программа с самого 
начала пишется на Python, то от низкоуровневых деталей можно 
уйти и сосредоточиться на функциональности приложения, воспользовавшись 
высокоуровневыми модулями. В главе 6 мы увидим, как 
это делается с помощью стандартного модуля xmlrpclib и мощного, 
но в то же время простого в использовании стороннего модуля RPyC.
Почти у всех программ есть какой-то пользовательский интерфейс, 
с помощью которого программе сообщают, что делать. На Python 
можно писать программы с интерфейсом командной строки, пользуясь 
модулем argparse, или с полноэкранным терминальным интерфейсом (
например, в Unix для этого предназначен сторонний пакет 
urwid; excess.org/urwid). Есть также много веб-каркасов – от простого 
bottle (bottlepy.org) до таких тяжеловесных, как Django (www.
djangoproject.com) и Pyramid (www.pylonsproject.org) – все они 
позволяют создавать приложения с веб-интерфейсом. И разумеется, 
на Python можно создавать приложения с графическим интерфейсом 
пользователя (ГИП).
Часто приходится слышать мнение, что ГИП-приложения скоро 
умрут, уступив место веб-приложениям. Но пока что этого не произошло. 
Более того, многие даже предпочитают приложения с графическим 
интерфейсом. Например, с тех пор как в начале 21 века обрели 
огромную популярность смартфоны, пользователи неизменно 
отдают предпочтение специально разработанным приложениям для 
повседневных задач, а не веб-страницам в браузере. На Python есть 
много сторонних пакетов для разработки графических приложений. 
Но в главе 7 мы рассмотрим, как создать приложение с современным 
графическим интерфейсом с помощью пакета Tkinter, входящего в 
стандартную библиотеку.