Сверхбыстрый Python. Эффективные техники для работы с большими наборами данных

Тиаго Антао
Сверхбыстрый Python
Эффективные техники для работы 
с большими наборами данных

Fast Python
HIGHT PERFORMANCE TECHNIQUES 
FOR LARGE DATASETS
TIAGO RODRIGES ANTÃO

Сверхбыстрый Python
ЭФФЕКТИВНЫЕ ТЕХНИКИ ДЛЯ РАБОТЫ 
С БОЛЬШИМИ НАБОРАМИ ДАННЫХ
ТИАГО АНТАО
Москва, 2023

УДК	 004.438Python:004.6
ББК 	 32.973.22
А72
Тиаго Антао
А72 	 Сверхбыстрый Python. Эффективные техники для работы с большими наборами данных / пер. с англ. А. Ю. Гинько. – М.: ДМК Пресс, 2023. – 370 с.: ил.
ISBN 978-5-93700-226-6
Данная книга предлагает уникальные техники ускорения выполнения 
кода на Python с акцентом на большие данные. Вы узнаете, как оптимизировать работу со встроенными структурами данных за счет конкурентного выполнения, а также научитесь сокращать объем занимаемой 
данными памяти без ущерба для их точности. Ознакомившись с тщательно проработанными примерами, вы узнаете, как добиться большей 
производительности популярных библиотек, таких как NumPy и pandas, 
и как эффективно обрабатывать и хранить данные. В книге используется целостный подход к повышению эффективности решений, так что 
вы научитесь оптимизировать и масштабировать целые системы – начиная от кода и заканчивая архитектурой.
Издание предназначено для разработчиков Python, знакомых с основами языка и принципами конкурентных вычислений.
УДК 004.438Python:004.6
ББК 32.973.22
DMK Press 2023.Authorized translation of the English edition©2023 Manning 
Publications.This translation is published and sold by permission of Manning 
Publications,the owner of all rights to publish and sell the same.
Все права защищены. Любая часть этой книги не может быть воспроизведена в какой бы то ни было форме и какими бы то ни было средствами без 
письменного разрешения владельцев авторских прав.
©  2023 by Manning Publications Co.
©  Оформление, издание, перевод, 
ДМК Пресс, 2023
ISBN  (анг.) 978-1-61729-793-9
ISBN  (рус.) 978-5-93700-226-6

Оглавление
Предисловие от издательства......................................................................... 11
Предисловие...................................................................................................... 13
Благодарности................................................................................................... 15
О книге............................................................................................................... 16
Об авторе........................................................................................................... 22
О переводчике................................................................................................... 23
Об изображении на обложке.......................................................................... 24
ЧАСТЬ I. ФУНДАМЕНТАЛЬНЫЕ ПОДХОДЫ................. 25
1 Острая нехватка производительности 
      при обработке данных............................................................27
1.1. Насколько велик всемирный потоп данных?.............................. 29
1.2. Современные вычислительные архитектуры 
и высокопроизводительные вычисления........................................... 33
1.2.1. Изменения в архитектуре компьютеров........................... 33
1.2.2. Изменения в архитектуре сети............................................ 36
1.2.3. Облако..................................................................................... 38
1.3. Работа с ограничениями языка Python......................................... 38
1.3.1.Глобальная блокировка интерпретатора............................ 40
1.4. Возможные решения....................................................................... 41
Заключение.............................................................................................. 44
2 Извлечение максимума возможного из встроенных  
       средств Python.................................................................. 46
2.1. Профилирование приложений с операциями  
        ввода-вывода и вычислениями....................................................... 48
2.1.1. Загрузка данных и поиск минимальной температуры........ 48
2.1.2. Встроенный в Python модуль профилирования............... 50
2.1.3. Использование локального кеша для снижения  
сетевой нагрузки.............................................................................. 51
2.2. Профилирование кода для обнаружения проблем 
с производительностью......................................................................... 53
2.2.1. Визуализация профилировочной информации............... 54
2.2.2. Профилирование с детализацией до строк...................... 55
2.2.3. Профилирование кода: выводы.......................................... 57
2.3. Оптимизация работы базовых структур данных Python:  
списки, множества и словари................................................................ 58
2.3.1. Быстродействие поиска в списке........................................ 59
2.3.2. Поиск с использованием множеств.................................... 60
2.3.3. Вычислительная сложность списков, множеств  
и словарей в Python......................................................................... 61

2.4. В поисках избыточного выделения памяти................................. 63
2.4.1. По минному полю выделения памяти в Python................ 64
2.4.2. Выделение памяти для альтернативных представлений.... 67
2.4.3. Использование массивов в качестве компактной  
альтернативы спискам.................................................................... 69
2.4.4. Систематизирование новых знаний:  
оценка объема памяти, занимаемой объектом........................... 71
2.4.5. Оценка занимаемой объектами памяти в Python:  
выводы............................................................................................... 72
2.5. Использование ленивых вычислений и генераторов  
для работы с большими данными......................................................... 73
2.5.1. Использование генераторов вместо обычных  
функций............................................................................................. 73
Заключение.............................................................................................. 75
3 Конкурентность, параллелизм и асинхронная обработка..... 77
3.1. Написание шаблона асинхронного сервера................................ 81
3.1.1. Разработка шаблона для взаимодействия с клиентами...... 83
3.1.2. Программирование с сопрограммами............................... 85
3.1.3. Передача сложных данных от простого  
синхронного клиента...................................................................... 87
3.1.4. Альтернативные способы передачи данных  
между процессами........................................................................... 88
3.1.5. Асинхронное программирование: выводы....................... 89
3.2. Реализация базового движка MapReduce..................................... 89
3.2.1. Описание фреймворка MapReduce.................................... 89
3.2.2. Разработка простейшего тестового сценария.................. 91
3.2.3. Первая реализация фреймворка MapReduce................... 92
3.3. Реализация конкурентной версии фреймворка MapReduce........ 93
3.3.1. Использование модуля concurrent.futures  
для реализации многопоточного сервера................................... 93
3.3.2. Асинхронное выполнение с использованием  
будущих объектов............................................................................ 95
3.3.3. Глобальная блокировка интерпретатора  
и многопоточность.......................................................................... 98
3.4. Реализация фреймворка MapReduce с использованием 
библиотеки multiprocessing................................................................... 99
3.4.1. Решение на основе модуля concurrent.futures................100
3.4.2. Решение на основе модуля multiprocessing.....................101
3.4.3. Отслеживание прогресса при использовании  
модуля multiprocessing..................................................................103
3.4.4. Передача данных порциями..............................................105
3.5. Собираем все воедино: асинхронный многопоточный 
и многопроцессный сервер MapReduce............................................109
3.5.1. Архитектура высокопроизводительного решения........109
3.5.2. Создание надежной версии сервера.................................113
Заключение............................................................................................115
Оглавление
6

Высокопроизводительный NumPy.................................... 117
4.1. Библиотека NumPy с точки зрения производительности......119
4.1.1. Копии и представления существующих массивов..........119
4.1.2. Внутреннее устройство представлений NumPy.............125
4.1.3. Эффективное использование представлений................131
4.2. Программирование на основе массивов....................................133
4.2.1. Отправная точка..................................................................135
4.2.2. Транслирование в NumPy..................................................135
4.2.3. Применение приемов программирования  
на основе массивов........................................................................138
4.2.4. Векторизуем сознание........................................................141
4.3. Оптимизация внутренней архитектуры NumPy.......................145
4.3.1. Обзор зависимостей в NumPy...........................................146
4.3.2. Настройка NumPy в дистрибутиве Python......................148
4.3.3. Потоки в NumPy..................................................................149
Заключение............................................................................................151
ЧАСТЬ II. АППАРАТНОЕ ОБЕСПЕЧЕНИЕ....................153
5 Реализация критически важного кода с помощью Cython.... 155
5.1. Обзор техник для эффективной реализации кода...................156
5.2. Беглый обзор расширения Cython..............................................158
5.2.1. Наивная реализация в Cython...........................................159
5.2.2. Использование аннотаций типов в Cython 
для повышения производительности........................................162
5.2.3. Как аннотации типов влияют на производительность........163
5.2.4. Типизация возвращаемых из функции значений...........166
5.3. Профилирование кода на Cython................................................167
5.3.1. Использование встроенной инфраструктуры 
профилирования Python..............................................................168
5.3.2. Использование line_profiler...............................................169
5.4. Оптимизация доступа к массивам в Cython с помощью 
memoryview.............................................................................................173
5.4.1. Использование представлений памяти...........................173
5.4.2. Избавление от всех взаимодействий с Python................175
5.5. Написание обобщенных универсальных функций NumPy  
на Cython.................................................................................................177
5.6. Продвинутая работа с массивами в Cython................................179
5.6.1. Обход ограничений GIL по запуску нескольких  
потоков одновременно.................................................................182
5.6.2. Базовый анализ производительности..............................186
5.6.3. Космические войны в Quadlife.........................................187
5.7. Параллелизм с Cython...................................................................189
Заключение............................................................................................190
6 Иерархия памяти, хранение данных и работа с сетью..... 192
6.1. Как современная архитектура аппаратных средств  
влияет на эффективность кода Python..............................................194
Оглавление
7

6.1.1. Неожиданное влияние современной архитектуры  
на производительность................................................................195
6.1.2. Влияние кеша процессора на эффективность  
алгоритма........................................................................................196
6.1.3. Современные устройства постоянного хранения.........198
6.2. Эффективное хранение данных при помощи Blosc.................199
6.2.1. Сжимаем данные, экономим время..................................199
6.2.2. Операции чтения (буферы памяти).................................201
6.2.3. Влияние алгоритма сжатия на эффективность  
хранения.........................................................................................202
6.2.4. Использование сведений о представлении данных  
для повышения эффективности сжатия....................................203
6.3. Ускорение NumPy с помощью NumExpr....................................204
6.3.1. Быстрая обработка выражений........................................205
6.3.2. Влияние архитектуры аппаратных средств  
на результаты..................................................................................206
6.3.3. Когда не стоит использовать библиотеку NumExpr......207
6.4. Производительность при использовании локальных сетей....... 208
6.4.1. Причины неэффективности вызовов REST...................209
6.4.2. Наивный клиент на основе UDP и msgpack....................209
6.4.3. Сервер на основе UDP........................................................211
6.4.4. Безопасность на клиенте с помощью тайм-аутов...........212
6.4.5. Прочие предпосылки для оптимизации сетевых 
вычислений....................................................................................214
Заключение............................................................................................214
ЧАСТЬ III. ПРИЛОЖЕНИЯ И БИБЛИОТЕКИ 
ДЛЯ СОВРЕМЕННОЙ ОБРАБОТКИ ДАННЫХ............217
7 Высокопроизводительный pandas и Apache Arrow............ 219
7.1. Оптимизация памяти и времени при загрузке данных............220
7.1.1. Сжатые и несжатые данные...............................................221
7.1.2. Определение типов данных колонок...............................222
7.1.3. Эффект изменения точности типа данных.....................226
7.1.4. Кодирование и снижение объема данных.......................227
7.2. Техники для повышения скорости анализа данных.................230
7.2.1. Использование индексирования для ускорения  
доступа к данным...........................................................................231
7.2.2. Техники перемещения по строкам...................................232
7.3. Взаимодействие pandas с NumPy, Cython и NumExpr..............235
7.3.1. Явное использование NumPy............................................236
7.3.2. Pandas поверх NumExpr.....................................................237
7.3.3. Cython и pandas....................................................................239
7.4. Чтение данных в pandas с помощью Arrow................................241
7.4.1. Взаимодействие между pandas и Apache Arrow..............241
7.4.2. Чтение из файла CSV..........................................................243
7.4.3. Анализ данных в Arrow.......................................................246
Оглавление
8

7.5. Использование механизма взаимодействий в Arrow для 
делегирования задач более эффективным языкам и системам.....247
7.5.1. Предпосылки архитектуры межъязыкового 
взаимодействия Arrow..................................................................247
7.5.2. Операции с нулевым копированием  
с использованием сервера Plasma от Arrow...............................249
Заключение............................................................................................254
8 Хранение больших данных................................................ 256
8.1. Универсальный интерфейс для доступа к файлам: fsspec........257
8.1.1. Использование fsspec для поиска файлов  
в репозитории GitHub..................................................................258
8.1.2. Использование fsspec для поиска zip-файлов..................260
8.1.3. Доступ к файлам с использованием библиотеки fsspec..... 260
8.1.4. Использование цепочки URL для обращения  
к разным файловым системам.....................................................261
8.1.5. Замена реализации файловой системы...........................262
8.1.6. Взаимодействие с PyArrow.................................................262
8.2. Parquet: эффективный формат хранения колоночных  
данных.....................................................................................................263
8.2.1. Исследование метаданных Parquet...................................264
8.2.2. Кодирование колонок в Parquet........................................266
8.2.3. Секционирование наборов данных..................................269
8.3. Работа с наборами данных, не помещающимися  
в памяти, по-старому.............................................................................271
8.3.1. Отображение в памяти с помощью NumPy.....................271
8.3.2. Порционирование данных при чтении и записи 
в датафрейм....................................................................................273
8.4. Использование Zarr для хранения больших массивов.............276
8.4.1. Знакомство с внутренней структурой формата Zarr......277
8.4.2. Хранение массивов в Zarr...................................................279
8.4.3. Создание нового массива...................................................282
8.4.4. Параллельное чтение и запись массивов в Zarr.............284
Заключение............................................................................................286
ЧАСТЬ IV. ПРОДВИНУТЫЕ ВОЗМОЖНОСТИ............289
9 Анализ данных с использованием графического процессора......291
9.1. Предпосылки для использования вычислительных  
мощностей GPU....................................................................................294
9.1.1. Преимущества использования графического процессора.....294
9.1.2. Связь между центральным и графическим  
процессорами.................................................................................297
9.1.3. Внутренняя архитектура графического процессора.....298
9.1.4. Архитектура программного обеспечения.......................299
9.2. Использование компилятора Numba для генерации кода  
под GPU.....................................................................................................300
Оглавление
9

9.2.1. Программное обеспечение для работы с GPU в Python..... 301
9.2.2. Основы программирования для GPU с помощью Numba....302
9.2.3. Создание генератора Мандельброта с помощью 
графического процессора............................................................306
9.2.4. Создание генератора Мандельброта с помощью NumPy.....309
9.3. Анализ производительности кода для GPU:  
приложение с использованием CuPy.................................................310
9.3.1. Библиотеки для анализа данных на базе GPU................310
9.3.2. Использование CuPy – версии библиотеки NumPy  
для GPU...........................................................................................311
9.3.3. Базовое взаимодействие с CuPy........................................311
9.3.4. Создание генератора Мандельброта с помощью Numba.....313
9.3.5. Создание генератора Мандельброта с помощью CUDA C....315
9.3.6. Средства профилирования кода для GPU.......................317
Заключение............................................................................................320
10 Анализ больших данных с использованием  
           библиотеки Dask......................................................... 321
10.1. Знакомство с моделью выполнения Dask.................................323
10.1.1. Шаблон pandas для сравнения........................................324
10.1.2. Решение на основе датафреймов Dask...........................326
10.2. Вычислительная стоимость операций Dask............................327
10.2.1. Секционирование данных для обработки.....................328
10.2.2. Сохранение промежуточных вычислений....................330
10.2.3. Реализации алгоритмов при работе  
с распределенными датафреймами............................................331
10.2.4. Рассекционирование данных..........................................334
10.2.5. Хранение распределенных датафреймов......................337
10.3. Использование распределенного планировщика Dask.........338
10.3.1. Архитектура dask.distributed...........................................340
10.3.2. Запуск кода с помощью dask.distributed.........................344
10.3.3. Работа с наборами данных, превышающими  
по объему доступную память........................................................350
Заключение............................................................................................351
Приложение А. Настройка окружения................................. 353
А.1. Установка Anaconda Python..........................................................354
А.2. Установка дистрибутива Python..................................................355
А.3. Использование Docker..................................................................355
А.4. Вопросы, касающиеся аппаратного обеспечения....................355
Приложение Б. Использование Numba для создания 
эффективного низкоуровневого кода...................................... 357
Б.1. Создание оптимизированного кода с помощью Numba.........359
Б.2. Написание параллельных функций в Numba...........................362
Б.3. Написание кода с использованием NumPy в Numba...............362
Предметный указатель........................................................ 365
Оглавление
10