/
Tags: языки программирования трансляторы
ISBN: 978-5-9228-3054-6
Text
С. А. Гутник
А. Н. Лата
Вычислительные
методы на Python
КН И ГА ВТОРАЯ
ИЗДАТЕЛЬСКИЙ ДОМ
МГИМО
с
МГИМО
ИЗДАТЕЛЬСКИЙ
дом
mMBMm
182^
Издательский дим МГИМО.
переплетая Запад и Восток, продолжает традиции
Типографии Лазаревского института восточных языков,
основанной в 1829 году
Moscow State Institute
of International Relations (University)
of the Ministry of Foreign Affairs
of the R ussian Federation
Department of Mathematics. Econometrics
and Information technology
Sergei Gutnik, Aleksandr Lata
Computational Methods
in Python
TEXTBOOK
IN TWO BOOKS
BOOK TWO (chapters 5 6)
Moscow
MGIMO University Publishing House
2026
Московский государственный институт
международных отношений (университет)
Министерства иностранных дел
Российской Федерации
Кафедра математики, эконометрики
и информационных технологий
С. А. Гутник, А. Н. Лата
Вычислительные методы
на । ’ython
УЧЕБНОЕ ПОСОБИЕ
В двух книгах
Кинга вторая (главы 5 6)
Утверждено редакционно издательским советом
МГИМО МИД России в качестве учебного пособия
Москва
Издательский дом МГИМО
2026
УДК 004.432(075.8)
БЕК 32.973.2я73
Г97
Рецензенты:
заместитель заведующего кафедрой информатики
и вычислительной математики МФТИ
доктор физико-математических наук, доцент В. И Голубев,
заведующий кафедрой эконометрики и математических методов экономики
Московской школы экономики МГУ имени М. В. Ломоносова
кандидат физико-математических паук, доцент А. Н. Курбацкий
В оформлении обложки использована картина Василия Кандинского
«Тридцать*. 1937. Национальный центр искусства и культуры
Жоржа Помпиду, Париж (ССО)
Г97
Гутиик, Сергей Александрович.
Вычислительные методы на Python : учебное пособие : в 2 книгах
С. А. Гутиик, А. Н. Лата ; Московский государственный институт меж-
дународных отношений (университет) Министерства иностранных дел
Российской Федерации, Кафедра математики, эконометрики и инфор-
мационных технологий. Москва : Издательский дом МГИМО. 2026.
ISBN 978-5-9228-3054-6
Книга 2 (главы 5 6). — 198, |1| с.
ISBN 978-5-9228-3075-1
DOI 10.63861/3075-1
Учебное пособие представляет собой базовый курс по программированию
на Python и предназначеао для формирования практических навыков автомати-
зации вычислений и анализа данных. Книга 1 знакомит с базовыми понятия-
ми, синтаксисом и конструкциями языка, закладывая фундамент алгоритмическо-
го мышления. Книга 2 даст представление об основных возможностях библиотек
NnniPy и pandas для работы с данными. Пособие содержит практические примеры
и блоки упражнений для закрепления навыков программирования.
Для студентов вузов, обучающихся по направлениям «Экономика», «Бизнес-
аналитика», «Менеджмент*, «Юриспруденция», «Торговое дело* и начинающих
изучать программирование.
УДК 004.432(075.8)
ББК 32.973.2я73
ISBN 978-5-9228-3075-1 (кп. 2)
ISBN 978-5-9228-3054-6
DOI 10.63861/3075-1
© Гутиик С. А., Лата А. Н.. 2026
© МГИМО МИД России. 2026
Оглавление
Глава 5. Основы работы с библиотекой NumPy....................... 9
§5.1 . Создание массивов..................................... 10
5.1.1. Функция пр. array О ............................ Г2
5.1.2. Функция пр. arange () 15
5.1.3. Функция пр linspaceO ............................. 17
5.1.4. Функция пр.zeros() 19
5.1.5. Функция пр.ones() 20
5.1.6. Функция пр.full() 21
5.1.7. Функция пр. eye О . 23
5.1.8. Функция пр. identity () ...........................25
5.1.9. Функция пр.empty() ................................26
5.1.10. Модуль пр.random . .............. 28
§5.2 . Свойства (атрибуты) массивов.........................31
§ 5.3. Индексирование и срезы...............................32
5.3.1. Индексирование.................................... 32
5.3.2. Срезы..............................................35
5.3.3. Булево индексирование..............................39
5.3.4. Индексирование массивами ........................ 40
§ 5.4. Изменение формы массивов.............................41
5.4.1. Функция пр reshape О...............................41
5.4.2. Функция пр.ravel () ...............................42
5.4.3. Функция пр.f lattenO............................. 44
§5.5 . Универсальные функции (ufunc)........................45
5.5.1. Арифметические операции............................48
§ 5.6. Агрегатные функции...................................50
5.6.1. Статистические функции........................... 51
5.6.2. Логические функции.................................53
§5.7 . Работа с уникальными значениями и частотой.............55
5.7.1. Функция пр. unique О...............................55
5.7.2. Функция пр.bincount()..............................57
§ 5.8. Работа с NaN и бесконечностью.......................59
§5.9 . Сортировка и поиск ................................... G1
5.9.1. Основные функции сортировки и поиска...............61
5.9.2. Сортировка массивов ............................. 63
5.9.3. Поиск индексов отсортированных элементов ..........66
5.9.4. Бинарный поиск.....................................67
5.9.5. Функция пр where О 70
§5.10 . Объединение массивов................................. 73
5.10.1. Функция пр concatenate О ........... 73
5.10.2. Функции np.stackO. np.hstackO и np.vstackO........75
§5.11 . Разделение массивов.................................. 79
5.11.1. Функция пр. split() ............................. 79
5.11.2. Функции пр.hsplitO, пр.vsplitO и np.dsplitO....... 81
§5.12 . Преобразование массивов.............................. 83
5.12.1 Изменение формы массива............................83
5.12.2. Добавление и удаление осей........................85
5.12.3. Удаление осей.....................................86
§5.13 . Копирование массивов................................. 87
§5.14 . Линейная алгебра с библиотекой NumPy..................88
5.14.1. Задание матриц и векторов ........................88
5.14.2. Транспонирование матриц.......................... 91
5.14.3. Сложение матриц...................................92
5.14.4. Вычитание матриц .................................94
5.14.5. Умножение матриц..................................94
5.14.6. Определитель и след матрицы.......................96
5.14.7. Обратная матрица..................................98
§5.15 . Норма вектора и норма матрицы ................ 99
§5.16 . Ранг матрицы....................................101
§5.17 . Решение систем линейных уравнений ..............102
§5.18 . Сингулярное разложение матрицы..................104
§5.19 . QR-разложение матрицы ..........................106
§ 5.20. Разложение Холецкого............................107
§5.21 . Собственные значения и собственные векторы......108
Контрольные вопросы ............................ 109
Практикум: работа с массивами NumPy.......................115
Заключение...............................................121
Глава 6. Основы работы с библиотекой pandas..................122
§6.1 . Основы Series и Data Frame ......................122
§6.2 . Загрузка и сохранение данных.....................133
§6.3 . Описательная статистика..........................143
§6.4 . Преобразование данных............................118
6.4.1. Изменение типа данных .........................148
6.4.2. Переименование столбцов ..................... 150
6.4.3. Добавление новых столбцов.................... 152
6.4.4. Удаление столбцов..............................156
6.4.5. Изменение индекса..............................157
6.4.6. Преобразование данных с помощью метода apply О . . . 160
§6.5 . Фильтрация данных................................163
6.5.1. Фильтрация по меткам и позициям................165
6.5.2. Фильтрация по значениям и диапазону............166
6.5.3. Фильтрация ио уникальным значениям и дубликатам . . 170
6.5.4. Фильтрация по пропущенным значениям............174
§6.6 . Группировка и агрегация данных.................. 176
§6.7 . Объединение таблиц...............................179
§ 6.8. Сводные таблицы..................................185
Контрольные вопросы........................................188
Практикум: работа с основными структурами pandas..........19'2
Заключение.................................................197
Список литературы.............................................198
Глава 5. Основы работы с библиотекой NumPy
NumPy (Numerical Python) — это фундаментальная библиотека для на-
учных вычислений и основа экосистемы анализа данных в Python. Ее ядром
является высокопроизводительный многомерный массив (ndarray) универ-
сальная структура для представления векторов, матриц и тензоров. Для эко-
номиста NumPy — это прежде всего инструмент для эффективной работы
с числовыми данными: макроэкономическими показателями, временными ря-
дами котировок, панельными данными или результатами моделирования. Биб-
лиотека предоставляет обширные математические функции для векторных
и матричных операций, статистической обработки и линейной алгебры, что де-
лает ее незаменимой для количественного анализа, построения моделей и вы-
полнения вычислений, требующих как скорости, так и высокой точности.
В стандартной библиотеке Python встроенные типы данных, такие как
списки, хороню подходят для решения небольших задач. Однако при обработке
больших объемов числовой информации они демонстрируют ряд существенных
ограничений: операции над элементами, выполняемые в циклах, отличаются
низкой скоростью; потребление памяти может быть избыточным; а поддерж-
ка целых классов продвинутых математических операций, таких как методы
линейной алгебры или сложные статистические функции, отсутствует.
NumPy решает эти проблемы, предоставляя компактную и однородную
структуру данных, а также реализуя ключевые математические операции в ви-
де высокооптимизированных низкоуровневых функций, написанных па С, C++
и Foreran. Это позволяет обходить медленный интерпретатор Python и вы-
полнять вычисления на скорости, близкой к машинному коду, что даст мно-
гократный, а зачастую и на порядки больший прирост производительности,
критически важный для работы с финансовыми временными рядами, макро-
экономическими моделями или большими панелями данных.
Исторически NumPy возник как преемник и объединитель двух более
ранних библиотек Numeric и Numarray. На сегодняшний день он является
де-факто стандартом для обработки массивных числовых данных в экосисте-
ме Python. Болес того, многие другие специализировавные библиотеки, такие
как Pandas для анализа табличных данных, SciPy для научных вычислений,
scikit-learn для машинного обучения, а также фреймворки вроде TensorFlow
и PyTorch для глубинного обучения, используют массивы NumPy в качестве
своих базовых структур данных. Поэтому глубокое понимание основ NumPy
необходимо каждому, кто планирует профессионально работать в области ана-
лиза данных, машинного обучения, научных расчетов и смежных дисциплин.
В данном пособии мы рассматриваем возможности NumPy с акцентом на
Python 3.13, но основные принципы и синтаксис остаются актуальными и для
более ранних версий языка. Перед началом работы рекомендуется убедиться,
что у вас установлена актуальная версия библиотеки, совместимая с Python
3.13. На момент подготовки издания актуальной стабильной версией NumPy
является 2.3.0. Полную и самую свежую документацию всегда можно найти на
официальном сайте проекта: https://numpy.org/doc/stable/.
Вкратце, ключевые возможности, которые предоставляет библиотека
NumPy, включают:
• Многомерные массивы (ndarray): эффективные структуры фиксиро-
ванного размера для компактного храпения и быстрой обработки одно-
родных данных.
• Векторизация: парадигма выполнения операций над целыми массивами
без использования явных циклов, что является залогом высокой скорости
вычислений.
• Универсальные функции (ufunc): оптимизированные функции, кото-
рые применяются поэлементно ко всем данным в массиве, обеспечивая
производительность на уровне низкоуровневых языков.
• Операции линейной алгебры: полноценная поддержка матричных опе-
раций, включая умножение, транспонирование, различные виды разложе-
ний и решение систем линейных уравнений.
• Статистические функции- обширный набор инструментов для вычис-
ления описательных статистик средних значений, дисперсий, корреля-
ций, перцентилей и других показателей.
§5.1. Создание массивов
Массив в программировании это базовая структура данных, предна-
значенная для храпения и обработки набора элементов одного типа, распо-
ложенных в непрерывной области памяти. Эта непрерывность обеспечивает
быстрый последовательный доступ к данным и является одним из ключевых
факторов производительности. В контексте NumPy эта концепция воплощена
в основном объекте библиотеки ndarray (n-dimensional array). Ndarray
представляет собой многомерный, однородный массив фиксированного разме-
ра, способный эффективно хранить и обрабатывать данные любой размерности:
от одномерных векторов и двумерных матриц до многомерных тензоров.
Однородность данных (все элементы массива имеют один и тот же тип)
и фиксированный размер при создании — это не ограничения, а осознанные
архитектурные решения. Именно они позволяют NumPy распределять намять
оптимальным образом и выполнять математические операции над целыми бло-
ками данных с максимальной скоростью, используя векторизацию. Для эконо-
миста это означает возможность мгновенно производить расчеты над всем вре-
менным рядом котировок, применять функцию к каждому элементу матрицы
макроэкономических показателей или агрегировать данные многомерного тен-
зора, представляющего, например, продажи по товарам, регионам и временным
периодам.
Таким образом, освоение методов создания массивов — это первый прак-
тический шаг к использованию вычислительной мощи NumPy. Библиотека
предлагает богатый набор функций для генерации массивов, каждая из ко-
торых оптимизирована для конкретного сценария. Правильный выбор метода
создания в зависимости от исходных данных и задачи позволяет сразу заложить
основу для эффективных последующих вычислений.
Перед тем как приступить к операциям с массивами, необходимо на-
учиться их корректно создавать (инициализировать). Основные способы созда-
ния массивов в NumPy включают:
• Создание из существующих объектов Python: функция
пр.array() -- основной способ преобразования списков, кортежей или
других итерируемых объектов в массив NumPy. Это точка входа для за-
грузки уже имеющихся данных.
• Генерация последовательностей чисел: функции np.arangeO (созда-
ние арифметической прогрессии с заданным шагом) и np.linspaceO (со-
здание последовательности с заданным числом равномерно распределен-
ных точек) идеальны для создания координатных осей, временных меток
или дискретизации интервалов.
• Создание массивов с постоянным значением функции пр. zeros О,
пр.ones() и пр.full() создают массивы, заполненные нулями, единица-
ми или любым другим указанным значением. Они часто используются для
инициализации параметров модели, создания масок или заготовок под по-
следующие вычисления.
• Генерация случайных данных: модуль пр.random содержит функции
для создания массивов, заполненных случайными числами из различных
распределений (равномерного, нормального и др.). Это незаменимый ин-
струмент для стохастического моделирования, генерации тестовых дан-
ных и методов Монте-Карло.
• Создание единичной и диагональной матриц, функции пр. eye О
и пр.identityO создают квадратную единичную матрицу, a np.diagO
диагональную. Опи фундаментальны для операций линейной алгебры.
• Создание «пустого» массива: функция пр. empty О выделяет память
под массив заданной формы и типа, но не инициализирует его значениями
(они могут быть произвольными). Это самый быстрый способ создания,
если массив будет полностью перезаписан в еле,дующей операции.
• Создание из итератора: функция np.fromiterO позволяет построить
массив из любого итерируемого объекта (например, генератора), что по-
лезно для работы с потоками данных без промежуточного сохранения
в списке.
Каждый из этих методов имеет своп особенности, область применения
и управляющие параметры, изучение которых позволяет гибки и эффектив-
но подготавливать данные для решения конкретных экономико-аналитических
задач.
5.1.1. Функция пр.array()
Функция пр. array О это основной и наиболее часто используемый спо-
соб создания массивов NumPy из уже существующих данных, представленных
в виде структур Python. Ее универсальность заключается в способности авто-
магически определять как размерность (число осей и форму), так и наиболее
подходящий тин данных (dtype) результирующего массива на основе анализа
переданного входного объекта. Это делает пр. array () идеальной точкой входа
для быстрого преобразования, например, списка котировок, вложенной табли-
цы данных или результатов какого-либо итерируемого вычисления в высоко-
производительный объект ndarray для последующего анализа.
Синтаксис функции с ключевыми параметрами представлен ниже:
Листинг 5.1: Синтаксис функции пр.array()
1 пр.array(objoct , drype = N'ne , copy = True , order=’K’, <->
—> subok-False, ndmin=O, like = None)
где
• object объект, который нужно преобразовать в массив (например, спи-
сок, кортеж и т. д.);
• dtype (необязательный) тип данных, который будет использоваться для
элементов массива (по умолчанию None, т. е. определяется автоматиче-
ски):
• сору (пеобязате 1ьный) если True, создается копия объекта, если False,
используется ссылка на объект (по умолчанию True);
• or der (необязательный) порядок, в котором элементы массива будут
располагаться в памяти (’С’ но строкам, Т’ — по столбцам, 'К' — со-
храняет порядок исходного объекта);
• subok (необязательный) если True, возвращается массив с тем же под-
классом, что и исходный объект (по умолчанию False);
• ndmin (необязательный) минимальное количество измерений, которое
должен иметь массив (по умолчанию 0);
• like (необязательный) — если задан, возвращается массив с тем же типом
данных и структурой, что и указанный объект (по умолчанию None).
Создадим одномерный массив из списка чисел.
Лнетин! 5.2: Создание одномерного массива из списка
1
2
3
4
6
# Импортируем библиотеку NumPy
import numpy as пр
# Создание одномерного массива из списка
а = пр array([1, 2, 3, 4, 5])
print (а) # Вывод [1 2 3 4 5]
IS данном примере мы импортируем библиотеку NurnPy в алиас пр
и используем функцию пр. array О, которая преобразует список чисел в од-
номерный массив длины пять. Функция пр. array О автоматически определяет
тип данных элементов массива и создаст массив с соответствующим типом. Ес-
ли элементы списка имеют разные типы. NumPy приведет их к общему типу,
что может привести к потере точности.
Аналогично можно создать массив из кортежа.
Создадим двумерный массив или матрицу из списка списков.
1
2
3
4
5
6
7
8
9
Листинг 5.3: Создание двумерного массива из списка списков
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерного массива из списка списков
b = пр.array ([ [1 , 2, 3], [4, 5, 6]])
pr int(b)
# Вывод:
# [[1 2 3]
# [456]]
В рассматриваемом примере мы создаем двумерный массив (матрицу)
из списка списков. Каждый вложенный список становится строкой двумерного
массива. NuniPy автоматически определяет размерность массива по количеству
вложенных списков и их длине.
Таким образом, функция пр. array О предоставляет полный контроль
над процессом создания массива, балансируя между удобством автомах пческо-
го вывода и мощью ручной настройки параметров, что является основой для
последующей эффективной работы с данными.
5.1.2. Функция пр. a range ()
Функция пр arangeO один из основных инструментов для создания
одномерных массивов с последовательностями чисел, равномерно распределен-
ных в заданном интервале с фиксированным шагом. По своей логике опа анало-
гична встроенной в Python функции range(), но, в отличие от нее, возвращает
не итератор, а готовый массив ndarray, что позволяет сразу использовать ре-
зультат в векторных операциях. Эта функция особенно полезна в тех случаях,
когда требуется сгенерировать последовательные числовые метки, временные
интервалы, индексы для выборки данных или дискретные оси для построения
графиков и моделей.
Синтаксис функции с основными параметрами имеет следующий вид:
Листинг 5.4: Синтаксис функции пр.arangeO
1 пр.arange([start], stopL, step], dtype = Ncne)
где
• start (необязательный) начальное значение диапазона (ио умолчанию
о);
• stop конечное значение диапазона (не включается в массив);
• step (необязательный) шаг между соседними значениями. По умолча-
нию равен 1. Может быть как целым, так и дробным числом, а также
отрицательным для создания убывающих последовательностей;
• dtype тип данных элементов результирующего массива. Если не указан,
NumPy определяет его автоматически на основе типов аргументов start,
stop и step
Важно отметить, что из-за ограничений точности чисел с плавающей
запятой при использовании нецелого шага количество элементов в результи-
рующем массиве может немного отклоняться от ожидаемого. Для задач, где
критически важен точный контроль над количеством точек (например, при дис-
кретизации временного ряда), часто предпочтительнее использовать функцию
np.linspaccO
Создадим одномерный массив с числами от 0 до 10 с шагом 2 с помощью
функции пр. arange О.
Листинг 5.5: Создание массива с помощью пр arange() с целым шагом
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива с помошью пр.arange()
а = пр.arange(0, 10, 2)
print (а) # Вывод [0 2 4 6 8]
Функция пр. arangeО полезна для создания последовательностей чисел,
например для генерации индексов, временных меток или других равномерно
распределенных значений.
Создадим одномерный массив с числами от 0 до 10 с дробным шагом 0.2
с помошыо функции пр. arange().
Листинг 5.6: Создание массива с помощью np.arangeO с дробным шагом
1 # Импортирует библиотеку NumPy
2 import numpy as пр
з # Создание массива с помошыо np.arangeO
4 а = пр arange(0, 10, 02)
s print(а)
в ft Вывод: [0. 0.2 0.4 0.6 0.8 1. 1.2 1.4 1.6 1.8
2. 2.2 2.4 2.6 2.8 3. 3.2 3.4 3.6 3.8 4. 4.2
‘Э 4.4 4.6 4 8 5, 5.2 5.4 5.6 5.8 6. 6.2 6.4 6.6
6.8 7. 7.2 7.4 7.6 7.8 8 8.2 8.4 8.6 3.3 9. ]
Таким образом, пр arangeO служит удобным и производительным стро-
ительным блоком для создания структурированных числовых последователь-
ностей. которые затем становятся основой для более сложных вычислительных
операций.
5.1.3, Функция пр.linspaceO
Функция пр. 1 inspace () предназначена для создания одномерных масси-
вов, содержащих заданное количество элементов, равномерно распределенных
на заданном числовом интервале. В отличие oi пр.arangeO, которая задает
последовательность через шаг и может иметь проблемы с точностью включе-
ния конечной точки при работе с числами с плавающей запятой, пр. linspace О
дает точный контроль над количеством точек и гарантирует, что обе границы
интервала будут включены в массив по умолчанию. Эта особенность делает
ее незаменимым инструментом дчя дискретизации непрерывных интервалов,
построения равномерных сеток для математического моделирования, создания
осей для графиков и любых задач, где важна предсказуемость и равномерность
распределения точек
Синтаксис функции с основными параметрами имеет следующий вид:
Листинг 5.7: Синтаксис функции пр. linspaceO
1 пр.linspace(start , stop, num-50, endpoint-True, <—’
retstep--False , dtype=None , axis~0)
где
start начальное значение диапазона;
• stop — конечное значение диапазона (включается в массив, если
endpoint=True);
• num (необязательный) — количество значений в массиве (по умолчанию
• endpoint (необязательный) — если True, то конечное значение вк почается
в массив (по умолчанию True);
• retstep (необязательный) если True, то возвращает также шаг между
значениями;
* dtype (необязательный) тип данных элементов массива;
• axis (необязательный) — ось. вдоль которой создастся массив.
Создадим одномерный массив с пятью равномерно распределенными
значениями па промежутке от 0 до 1, включая конечное значение с помощью
функции np.linspaceO.
Листинг 5.8: Создание массива с помощью пр. linspaceO
1
2
3
4
6
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива с помощью np.linspaceO
а = пр.linspace (0 , 1, пиш=5)
print(a) # Вывод: [0. 0.25 0.5 0.75 1. ]
Для получения шагов между значениями можно использовать параметр
retstep=True.
Листинг 5.9: Создание массива с шагом с помощью np.linspaceO
1
2
3
4
5
6
7
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива с помощью np.linspaceO
a, step = пр.1 inspace(0, 1, num=5, retstep=Truc)
print(а) # Вк'од: [0. 0.25 0.5 0.75 1.
print(step) # Вывод: 0.25
5.1.4. Функция пр.zeros О
Библиотека NumPy предоставляет набор высокоонтимизированиых
функций для создания массивов, предварительно заполненных конкретными
значениями Среди них ключевую роль играет функция пр. zeros О, предназна-
ченная для генерации массивов любой размерности, все элементы которых ини-
циализированы нулями. Создание «нулевых» массивов — это фундаментальная
операция, которая часто служит отправной точкой для многих вычислительных
процессов. Для экономиста или аналитика это эквивалентно подготовке чисто-
го холста или заготовки структурированной таблицы перед тем, как заполнить
се результатами расчетов, аккумулированными статистиками или промежуточ-
ными данными модели.
Синтаксис функции с основными параметрами имеет следующий вид:
Листинг 5.10: Синтаксис функции пр.zeros()
1 пр zeros(shape, dtype=float, order=’C’)
где
* shape форма создаваемого массива (например, shape = (2, 3) создаст
массив размером 2x3);
* dtype (необязательный) тип данных элементов массива (ио умолчанию
float);
* order (необязательный) порядок хранения многомерного массива в па-
мяти (’С* 1 2 для строкового, ’F’ для столбцового).
Создадим двумерный массив 2x3, заполненный пулями, с помощью
функции пр zeros().
Листинг 5.11: Создание массива с помощью np.zcros()
—
I # Импортируем библиотеку NumPy
2 import numpy as пр
з
4
5
6
7
8
9
# Создание массива с помощью пр.zeros()
а = пр zeros((2, 3) )
print(а)
# Вывод;
# [[0 0. 0.]
# [0. О 0.]]
Инициализация пулями критически важна в сценариях, где требуется
гарантировать определенное начальное состояние данных, исключив влияние
«мусора» из памяти, или когда алгоритм предполагает постепенное накопление
результатов (например, расчет накопленного итога, агрегация сумм по катего-
риям или итеративное решение системы уравнений). Кроме того, нулевые мас-
сивы широко используются как основа для создания бинарных масок, представ-
ления отсутствующих операций в матрицах или задания начальных параметров
в оптимизационных задачах.
5.1.5. Функция пр .ones()
Функция пр.ones() является логическим продолжением семейства
функций для создания предзаполнеппых массивов и предназначена для генера-
ции массивов заданной размерности, все элементы которых инициализируются
числом 1. Если пр.zeros() предоставляет «нейтральный элемент» для опера-
ций сложения и вычитания, то пр. ones О часто выступает в аналогичной роли
для операций умножения и деления. Создание массивов, заполненных единица-
ми, является распространенной практикой для инициализации параметров мо-
делей, где начальное значение должно быть нейтральным относительно умно-
жения, для построения масок с логическим условием «истина» или для быст-
рого формирования структур, которые впоследствии будут масштабированы
(умножены па нужный коэффициент).
Синтаксис функции полностью аналогичен пр zeros О и предусматри-
вает те же ключевые параметры для контроля формы и типа данных:
Листинг 5.12: Синтаксис функции пр ones О
—
1 пр.ones(shape, dtype=float , order=’C’)
где
• shape — форма создаваемого массива (например, shape = (2, 3) создаст
массив размером 2x3);
• dtype (необязательный) тип данных элементов массива (по умолчанию
float);
• order (необязательный) порядок хранения многомерного массива в па-
мяти (’С’ для строкового, ’F’ для столбцового).
• order (необязательный) — порядок хранения многомерного массива в па-
мяти (’С’ для строкового. F’ для столбцового).
Создадим двумерный массив 2x3, заполненный единицами, с помощью
функции пр. ones ()
Листинг 5.13: Создание массива с помощью np.ones()
1 # Импортируем библиотеку NumPy
2 import numpy as пр
з # Создание массива с помощью пр.ones О
4 а = пр . ones ((2 , 3) )
s print(а)
в # Вывод:
7 # [[1. 1. 1.J
8 # [1.1.1.]]
5.1.6. Функция пр full О
Функция пр. full О обобщает идеи функций пр. zeros О и пр. ones О,
предоставляя возможность создать массив заданной формы, каждый элемент
которого заполнен одним и тем же, явно указанным пользователем значением.
Эта функция незаменима в ситуациях, когда требуется инициализировать мас-
сив нс нулевой или единичной, а произвольной константой: например, старто-
вым значением итеративного алгоритма, значением по умолчанию, специальной
меткой или конкретным числовым порогом. Использование np.fullO делает
код более выразительным и эффективным по сравнению с последовательным
созданием массива через пр.zeros() с последующим присваиванием, так как
заполнение происходит на низком уровне в момент создания.
Синтаксис функции добавляет один обязательный аргумент значение
для заполнения:
Листинг 5.14: Синтаксис функции пр . full О
1 пр . full (shape , fill_value, dT.ype = None , order=’C’)
где
• shape форма создаваемого массива (например, shape = (2, 3) создаст
массив размером 2x3);
• fill_value значение, которым будет заполнен массив;
• dtype (необязательный) — тип данных элементов массива (по умолчанию
определяется автоматически);
• order (необязательный) порядок храпения многомерного массива в па-
мяти (’С’ дчя строкового, ’F1 для столбцового);
• fill_value — значение, которым будет заполнен массив:
• dtype (необязательный) тип данных элементов массива (по умолчанию
определяется автоматически);
• order (необязательный) — порядок хранения многомерного массива в па-
мяти (’С’ для строкового, ’F’ для столбцового).
Создадим двумерный массив 2 х 3, заполненный значением 7, с помощью
функции пр. full О
Листинг 5.15: Создание массива с помощью пр. full О
—
1 # Импортируем библиотеку NumPy
2 import numpy as пр
з # Создание массива с помощью пр.full()
4 а = пр full((2, 3), 7)
5 print(а)
в # ывод:
? # [[7 7 7]
s # [7 7 7]]
5.1.7. Функция пр.eye()
В линейной алгебре, лежащей в основе многих экономико-математичес-
ких моделей, особая роль отводится единичной матрице. Это квадратная мат-
рица, у которой все элементы главной диагонали равны единице, а все осталь-
ные элементы — нулю. Она является аналогом числа «1» в мире матриц и
выполняет функцию нейтрального (единичного) элемента при операции умно-
жения матриц: умножение любой матрицы па подходящую по размеру единич-
ную матрицу (слева или справа) оставляет исходную матрицу неизменной. Это
свойство делает единичную матрицу фундаментальным инструментом при ре-
шении систем линейных уравнений (например, в методах нахождения обратной
матрицы), в регрессионном анализе, при работе с линейными преобразованиями
и в алгоритмах машинного обучения.
NumPy предоставляет две основные функции для создания единичной
матрицы: пр.еуеО и пр. identity (). Функция пр.еуеО является более гиб-
кой, гак как позволяет создавать нс только строго квадратные матрицы, но
и прямоугольные (в этом случае единицы будут расположены на главной диа-
гонали, размер которой определяется минимальным измерением), а также сме-
щать диагональ с единицами относительно главной.
Синтаксис функции с основными параметрами имеет следующий вид:
Листинг 5.16: Синтаксис функции пр. eye О
1 np.eye(N, M = None , k = 0, dtype=float)
где
• N количество строк в матрице;
• М (необязательный) количество столбцов в матрице (по умолчанию M=N);
• к (необязательный) индекс диагонали, на которой будут находиться
единицы (по умолчанию 0, главная диагональ);
* dtype (необязательный) тин данных элемен тов матрицы (по умолчанию
float).
Создадим двумерную единичную матрицу размером 3 х 3 с помощью
функции пр. eye().
Листинг 5.17: Создание двумерной единичной матрицы с помощью пр.eyeQ
1 # Импортируем библиотеку KumPy
2 import numpy as пр
з
4 # Создание двумерной единичной матрицы с помощью «—
пр. eye О
s а = пр eye (3)
6 print(a)
? U £ьвод:
8 # [[1. 0. 0.]
9 # to. 1. 0.]
ю it [0. 0. l.J]
Кроме того, можно создать «прямоугольную» единичную матрицу, ука-
зав количество строк и столбцов. По умолчанию единицы в такой матрице будут
располагаться на позициях (г, j), где i помер строки, a j номер столбца.
Например, создадим прямоугольную единичную матрицу размером 2 х 3 с по-
мощью функции пр. eye О.
# Импортируем библиотеку NumPy
import numpy as пр
# Создание прямоугольной единичной матрицы с помощью*-^
— > пр.еуеО
а = пр eye (2, 3)
print(а)
# Вывод:
# [[1. 0. 0.J
# [G 1. 0.]]
Листинг 5.18: Создание прямоугольной единичной матрицы с помощью
пр eye()
1
2
3
4
6
7
8
9
5.1.8. Функция пр. identityO
Функция пр.identity(N) является частным случаем пр.eye(N) и созда-
ет строго квадратную единичную матрицу размера N х ЛГ.
Синтаксис функции с основными параметрами выглядит следующим об-
разом:
Листинг 5.19: Синтаксис функции пр . identityO
1 пр.identity(п , dtype = float)
где
• п — размерность единичной матрицы (количество строк и столбцов);
• dtype (необязательный) тип данных элементов матрицы (по умолчанию
float).
Создадим двумерную единичную матрицу размером 3 х 3 с помощью
функции пр. identityO
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерной единичной матрицы с помощью <—’
пр . identity О
а = пр.identity(3)
print(а)
« Вывод:
# [[1 . 0 0.]
# [0. 1. 0.]
И [0. 0. 1.]]
Листинг 5.20: Создание двумерной единичной матрицы с помощью
пр.identity()
1
2
3
<1
ь
7
8
9
10
Функция пр . identity О полезна для создания единичных матриц, ко-
торые часто используются в линейной алгебре, например при решении систем
линейных уравнений или в качестве нейтрального элемента при умножении
матриц.
5.1.9. Функция пр.empty()
Ранее мы рассмотрели функции, которые создают массивы, явно запол-
ненные конкретными значениями: нулями, единицами или произвольной кон-
стантой. Однако в высокопроизводительных вычислениях зачастую критически
важна скорость, и шаг инициализации может стать излишней затратой време-
ни, если массив предназначен для немедленной полной перезаписи. Для таких
сценариев NumPy предоставляет функцию пр. empty О, которая создает массив
заданной формы и типа данных без инициализации его элементов. Это означа-
ет, что выделяется блок памяти соответствующего размера, но его содержимое
остается тем, что находилось в этой области памяти ранее (так называемые
«мусорные» значения).
Использование пр. empty О требует от программиста особой аккуратно-
сти необходимо гарантировать, что все элементы массива будут перезаписа-
ны до их чтения, иначе неопределенные значения приведут к непредсказуе-
мым ошибкам в вычислениях, которые крайне сложно отладить. Тем не менее,
в ситуациях, где производительность является ключевым фактором, например,
внутри интенсивных циклов, при реализации численных алгоритмов, где массив
сразу заполняется результатами вычислений, или при работе с очень большими
массивами, где даже однократный проход для инициализации нулями занимает
заметное время, эта функция становится незаменимым инструментом. Она поз-
воляет избежать двойной работы — сначала записи нулей, а затем фактических
данных.
Синтаксис функции полностью аналогичен пр. zeros О и пр. ones О:
Листинг 5.21: Синтаксис функции пр.empty()
1
пр.empty(shape , dtype=float , ordei=’C’)
где
• shape форма создаваемого массива (например, shape = (2, 3) создаст
массив размером 2x3);
• dtype (необязательный) тип данных элементов массива (по умолчанию
float);
• order (необязательный) порядок хранения многомерного массива в па-
мяти (’С’ для строкового. ’F’ для столбцового).
Создадим двумерный массив 2 х 3 с помощью функции пр. empty О
Листинг 5.22: Создание массива с помощью пр.empty()
1 # Импортируем библиотеку NumPy
2 import numpy as пр
з
4
5
6
7
в
» Создание массива с помощью пр.empty()
а = пр empty((2, 3))
print (а)
# Вывод (значения могут быть случайными) :
# [[3.47739835e-0Sl 8.43864123е-321 0.00000000е+000]
э Я [6. 75161440е-312 0.00000000е+000 6.74794694е-312]]
В данном примере мы создали двумерный массив 2 х 3, по значения
в нем не инициализированы, поэтому они могут быть случайными и могут со-
держать «мусорные данные» из памяти. Поэтому перед использованием такого
массива необходимо заполнить его значениями.
5.1.10. Модуль пр. random
Статистическое моделирование, оценка рисков, метод Монте-Карло, ге-
нерация тестовых данных и симуляция стохастических процессов все эти
задачи требуют работы со случайными величинами. Для их решения NumPy
предлагает универсальный модуль пр.random, который содержит обширный на-
бор функций для генерации случайных чисел и массивов, подчиненных различ-
ным теоретическим распределениям: равномерному, нормальному, биномиаль-
ному, пуассоновскому и многим другим.
Функция пр. г andom. rand () создаст массив заданной размерности, за-
полненный случайными числами из непрерывного равномерного распределения
на полуинтервале |().О. 1.0). Форма массива задается отдельными аргументами,
а нс кортежем. Синтаксис функции следующий:
Листинг 5.23: Синтаксис функции пр.random.rand()
i пр.random.rand(dO , dl , ...» dn, dtype=None, order=’C’)
где
• dO, dl, ..., dn размеры создаваемого массива (например,
пр.random.rand(2, 3) создаст массив размером 2 х 3);
• dtype (необязательный) — тип данных элементов массива (но умолчанию
определяется автоматически);
• order (необязательный) — порядок хранения многомерного массива в па-
мяти ('С’ для строкового, ’F’ для столбцового).
Создадим двумерный массив 2x3. заполненный случайными числами
с помощью функции пр.random.гand().
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива с помощью пр.random.rand О
а = пр random.rand(2, 3)
print(а)
# Вывод (значения будут случайными):
» [[0.12345678 0.23456789 0.3456789 ]
# [0.45678901 0.56789012 0.6789012311
Листинг 5.24: Создание массива с помощью пр. random. rand()
i
2
3
4
5
6
7
8
0
fl данном примере мы создали двумерный массив 2x3. заполненный
случайными числами из непрерывного равномерного распределения на полу-
интервале [0.0, 1.0). При каждом запуске программы значения в массиве будут
разными, так как они генерируются случайным образом.
Для воспроизводимости результатов можно установить начальное зна-
чение для генератора случайных чисел с помощью функции
пр.random.default_rng(). Например, если вы хотите получить одинаковые
случайные числа при каждом запуске программы, можно сделать так:
Листинг 5.25: Установка начального значения генератора случайных чисел
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем генератор случайных чисел
гng = пр.random.default.rng(seed=42)
# Создание массива с помощью пр.random.rand О
а = rng.random((2, 3))
print(а)
# Вывод:
ю # [[0.77395605 0.43887844 0.85859792]
и # [0.69736803 0.09417735 0.97562235]]
Устаревший способ установки начального значения генератора
случайных чисел с помощью функции пр.random seed() также работает, но
рекомендуется использовать новый интерфейс пр random.default_rng() для
большей । нбкости и контроля над генерацией случайных чисел.
Модуль пр. random предоставляет множество других функций для гене-
рации случайных чисел из различных распределений:
• пр.random.randint(low, high=None, size=None, dtype=int) генера-
ция случайных целых чисел в заданном диапазоне;
• пр.random.normal(1ос=0.0, scale=1.0, size=None) — генерация слу-
чайных чисел из нормального распределения с заданным средним (1ос)
и стандартным отклонением (scale):
• np.random.uniform(low=0.0, high=1.0, size=None) генерация слу-
чайных чисел из равномерного распределения на заданном отрезке [low,
high);
• пр random.shuffle(x) перемешивание элементов массива х на месте;
• пр.random.sample(а, п, replace=False, weights=None) случайная
выборка п элементов из массива а без повторений (replace=False) с воз-
можностью задания весов для каждого элемента (weights).
Другие функции модуля пр. random позволяют генерировать случайные
числа из различных распределений, что делает его мощным инструментом для
работы с вероятностными моделями и статистическими анализами. Подроб-
нее о функциях модуля пр.random можно узнать в официальной документации
NumPy https: //numpy. org/doc/stable/ref erence/random/index. html.
§ 5.2. Свойства (атрибуты) массивов
После создания массива важно уметь быстро получить информацию
о его размерах, форме, типе данных и памяти. NumPy предоставляет атри-
буты ndarray, которые помогают попять, как устроен массив, и оптимизировать
дальнейшие вычисления.
Основные свойства (атрибуты) массива в NumPy включают:
• Форма (shape): определяет размерность массива и количество элемен-
тов в каждой осп. Например, для двумерного массива форма может быть
(строки, столбцы), например, (2, 3) для массива с 2 строками и 3 столб-
цами.
• Размерность (ndim) количество измерений массива (например, одно-
мерный. двумерный и т. д.).
* Количество элементов (size), общее количество элементов в массиве.
• Тип данных (dtype): тип данных элементов массива (например, целые
числа, числа с плавающей запятой и т. д.).
• Размер элемента (itemsize): размер одного элемента массива в байтах.
Листинг 5.26: Свойства массива в NumPy
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива
а = пр аггау([[1, 2, 3] , [4, 5, 6]])
# Получение свойств массива
shape = a.shape tt Форма массива (количество строке^
* —> и столбцов)
ndim - a. ndim # Количество измерений
- э (размерность)
size = a.size # Общее количество элементов в<—>
с -> массиве
10
11
12
13
14
15
16
17
dtype = а.dtype
itemsize = a.itemsize # Размер одного элемента массив
ч ва в байтах
# Вывод свойств массива
print("Форма:", shape) * и од: (2, 3)
print("Размерность ", ndim) # Вь юд 2
print("Количество элементов:", size) # Вывод 6
print("Тип данных.", dtype) # Вывод int32
print("Размер элемента:", itemsize) » Вывс 4
§5.3. Индексирование и срезы
Индексирование и срезы являются краеугольным камнем при работе
с массивами: благодаря ним можно выбирать элементы, подмассивы и изме-
нять данные без полного копирования. В NumPy индексирование мощнее, чем
в списках Python: поддерживается многомерное индексирование, булево, индек-
сирование массивами (fancy indexing)!! другие механизмы.
5.3.1. Индексирование
Индексирование в NumPy позволяет получать доступ к элементам мас-
сива и манипулировать ими. Как и в стандартных списках Python, индексация
начинается с нуля, а также поддерживается отрицательная индексация (отсчет
с конца массива).
Для одномерного массива используется один индекс, для многомерного
кортеж индексов (но одному на каждое измерение). Важное отличие от списков
Python: результатом индексирования многомерного массива может быть как
скалярное значение, так и массив меньшей размерности.
Рассмотрим одномерный массив и получим доступ к его элементам
с помощью индекса.
Листинг 5.27: Получение элемента одномерного массива по индексу в NumPy
1
2
3
4
в
7
8
# Импортируем библиотеку NumPy
import numpy as пр
# Создание одномерного массива
а = пр array([1, 2, 3, 4, 5])
# Индексирование для получения элемента
element = а [2] # Получаем третий элемент (индекс 2)
print("Элемент•", element) t Вывод 3
Для двумерного массива можно использовать кортеж индексов, чтобы
получить доступ к элементам ио строкам и столбцам, используют следующий
синтаксис: синя массива>[<индекс строки>, <индекс столбца>]
Листинг 5.28: Получение элемента двумерного массива, по индексу в NumPy
1
2
3
4
6
7
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерного массива
а = пр array ((L1, 2, 3] , [4, 5, 6]])
# Индексирование для получения элемента
element = а [0, 1] # Получаем элемент в первой строка—»
> е и втором стс лбце
print("Элемент, element) # Bi од 2
Аналогичным образом можно получить доступ к строкам и столбцам
массива. Например, чтобы получить всю строку или столбец, можно использо-
вать следующий синтаксис:
Листинг 5.29: Получение строки и столбца двумерного массива в NumPy
1
2
3
4
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерного массива
3
6
7
8
9
10
11
а = пр аггау([[1, 2, 3], [4, 5, 6]])
# Индексирование для получения строки
row = а[1] й Получаем вторую строку
print("Строка, row) # Выво^ [4 5 6.
# Индексирование для получения столбца
column = а[:, 1] # Получаем второй столбец
pr Int (" Столбец , column) я В->. >од 2 5]
Индексирование также поддерживает отрицательные индексы, которые
позволяют обращаться к элементам с конца массива (например, -1 - последний
элемент, -2 предпоследний и т. д.).
Получим элемент одномерного массива с помощью отрицательного ин-
декса.
Листинг 5.30: Получение элемента одномерного массива с помощью отрица-
тельного индекса в NumPy
1
а
з
4
5
6
7
8
# Импортируем библиотеку NumPy
import numpy as пр
# Создание одномерного массива
а = пр аггау([1, 2, 3, 4, 5])
# Индексирование для получения элемента с отрицатель^
с—> ним индексом
negative_index = а [-1] # Получаем последний элемент
print("Элемент с отрицательным индексом:", * ’
«-) negative_index) # Вывод 5
Для двумерного массива можно использовать отрицательные индексы
для получения элементов с конца строк и столбцов.
Листинг 5.31: Получение элемента двумерного массива с помощью отрицатель-
ных индексов в NumPy
—
1 # Импортируем библиотеку NumPy
г import numpy as пр
3
4
5
6
7
8
# Создание двумерного массива
а = пр аггау([[1, 2, 3], L4, 5, G] ])
# Индексирование для получения элемента с отрицатель* *—>
ным индексом
negative, index = а[-1, -2] # Получаем элемент в пос*-^
> ледней строке и предпоследнем столбце
print("Элемент с отрицательным индексом ", <->
— > negative.index) ff Вывод. 5
5.3.2. Срезы
Срезы (slicing) в NumPy используют синтаксис, аналогичный срезам
в списках Python, но предоставляют значительно более мощные возможности,
особенно при работе с многомерными массивами. Срезы позволяют извлекать
подмассивы, включая отдельные строки и столбцы, а также изменять данные
непосредственно в исходном массиве без создания копий.
Синтаксис срезов в NumPy следующий:
Листинг 5.32: Синтаксис срезов в NumPy
1 <имя массива) [<начальный индекс) <конечный индекс)*-1
<—> [ : <шаг>] ]
L
где
• <имя массива> имя массива, из которого будет получен срез;
• <начальный индекс> индекс, с которого начинается срез (включитель-
но);
• скснезный индекс> — индекс, на котором заканчивается срез (не включи-
тельно);
• <.шаг> (необязательный) — шаг среза (по умолчанию 1).
Получим срез одномерного массива, который содержит элементы с ин-
дексами от 1 до 3 (включительно).
Листинг 5.33: Срез одномерного массива в NumPy
1
2
3
4
5
6
7
8
# Импортируем библиотеку KumPy
import numpy as пр
# Создание одномерного массива
а = пр аггау([1, 2, 3, 4, 5])
и Срез для получения элементов с индексами от 1 до н
3 (включительно)
sliced_array = а [ 1;4]
print("Срез массива:", sliced_array) 4 Вы од [2 3 1]
Для многомерных массивов срезы можно применять к каждому измере-
нию отдельно через запятую.
Для двумерного массива срезы позволяют извлекать строки, столбцы
и подмассивы. Получим первые две строки с помощью среза, а также первые
два столбца и подмассив из правого нижнего угла.
Листинг 5.34: Срез двумерного массива в NumPy
1
2
3
4
5
6
7
8
9
10
II
12
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерного массива
а = пр.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Срез для получения первых двух строк
sliced_rows = а [:2]
print("Срез первых двух строк:\п" , sliced.rows)
# Вывод:
# [[1 2 3]
# [456]]
# Срез для получения первых двух столбцов
13
14
15
16
17
18
19
20
21
22
23
24
sliced.columns = а[:, :2]
рг!пт("Срез первых двух столбцов :\n" , sliced_columns )
# Вывод:
# [[1 2J
# [4 5]
# [7 8]]
# Срез для получения подмассива из правого нижнего ун
гла
sliced..subarray = а[1: , 1:]
print("Срез подмассива из правого нижнего угла:\п", »
> sliced.subarray)
# Вывод:
# [[56]
# [8 9]]
Срезы также поддерживают отрицательные индексы, что позволяет из-
влекать элементы с конца массива. Получим срез двумерного массива, который
содержит последние две строки и последние два столбца.
Листинг 5.35: Срез двумерного массива с отрицательными индексами в NumPy
1
2
3
<1
5
б
7
а
9
10
11
12
13
14
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерного массива
а = пр аггау([[1, 2, 3] , [4, 5, 6] , [7, 8, 9]])
# Срез для получения последних двух строк
sliced_rows = а[-2:]
print("Cpe3 последних двух строк \n", sliced.rows)
# Вывод:
# [[4 5 6]
« [739]]
# Срез для получения последних двух столбцов
siiced_columns = a[:, -2:]
print("Срез последних двух столбцовДп", *
с-> sliced_columns)
15
16
17
18
19
20
21
22
23
21
# Вывод:
# [[23]
# [5 6]
# [89]]
# Срез для получения подмассива из правого верхнего
угла
sliced_subarray = а[:2, -2.]
print ("Срез подмассива из правого верхнего угла<-^
> \n", siiсed_subarray)
# Вывод:
# [[2 3]
# [5 6]]
Отметим, что ключевое отличие срезов в NumPy от срезов
в Python заключается в том. что срезы в NumPy возвращают представле-
ние (view) исходного массива, а не копию данных. Это означает, что измене-
ния, внесенные в представление, затрагивают исходный массив, что позволяет
эффективно работать с большими данными без потребления дополнительной
памяти.
Листинг 5.36: Изменение элемента в представлении среза в NumPy
1
2
3
4
6
7
8
9
10
11
12
import numpy as пр
# Создание массива
агг = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# Демонстрация view (представления)
slice_view = arr[2:7]
pr int (slice_view) # Вывод [2 3 4 5 6j
H Изменение элемента в представлении
slice.view [0] = 100
print(arr)
# Вывод; [ 0 1 100 3 4 5 6 7 8 9] ♦-*
w - исходный массив изменился
В примере выше мы демонстрируем, что изменение элемента в представ-
лении среза в NuniPy изменяет исходный массив.
Замечание 1. Хотя базовые срезы возвращают представление, некоторые типы
расширенного индексирования (например, с использованием массивов индексов
пли булевых масок) всегда возвращают новый массив (копию данных).
5.3.3. Булево индексирование
Булево индексирование в NuniPy позволяет выбирать элементы массива,
соответствующие определенному условию. Для этого создается булева маска,
которая содержит значения True для элементов, удовлетворяющих условию, и
False для остальных. Затем эта маска используется для индексирования масси-
ва. что позволяет извлекать только те элементы, которые соответствуют усло-
вию.
Например, если нужно выбрать все четные элементы из массива, можно
создать булеву маску, которая будет True для четных элементов и False для
нечетных.
Листинг 5.37: Булево индексирование в NumPy
1
2
3
4
5
6
7
3
9
10
11
12
13
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива
а = пр.array([1, 2, 3, 4, 5])
# Создаем булеву маску для четных элементов
even_mask = а 7, 2 == О
print("Булева маска для четных элементов:", even.mask)
в Вывод' [False True False True False]
# Используем булеву маску для выбора четных элементов—'
-» в
even.elements = a[even_mask]
print("Четные элементы :", even_elements)
# Вывод: Четные элементы: [2 4J
Булево индексирование позволяет эффективно фильтровать данные, не
создавая дополнительных копий массива.
5.3.4. Индексирование массивами
Индексирование массивами (fancy indexing) позволяет выбирать эле-
менты массива но списку индексов. Это полезно, когда нужно получить эле-
менты по неупорядоченному набору индексов.
Листинг 5.38: Индексирование массивами в NumPy: одномерный случай
1
2
3
4
о
6
8
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массива
а = пр array([10, 20, 30, 40, 50])
indices = [0, 2, 4] # Массив индексов элементов, кон
«-Э торые нужно выбрать
sei ected_el ement s = a[indices] # Индексжро и с пн
> омощью массива индексов
print("Элементы, выбранные с помощью массива индексов-»
•—> в:", select ed_el ement s )
# Зывод: Элементы, выбранные с помощью массива индекН»
«-» сов. [10 30 50]
Индексирование массивами также поддерживается для многомерных
массивов, что позволяет выбирать элементы по спискам индексов для каждой
оси.
Листинг 5.39: Индексирование массивами в NumPy: двумерный случай
1
2
3
4
# Импортируем библиотеку NumPy
import numpy as пр
# Создание двумерного массива
5
6
7
8
9
10
11
а = пр array ([[1, 2, 3] , [4, 5, 6], [7, 8, 9]])
if Индексирование массивами: задаем массивы индексов <-
—* для строк и столбцов
row.indices =[0,2] и Массиг индексо! строк
col_indices = [1, 2] Я Массиг индекс .1 столбце
selected.elements_2d = а [row.indices, col.indices]
print("Элементы, выбранные с помощью массивов индексе-»
<—> ов:", selected.elements.2d)
# Вывод: Элементы, выбранные с помощью массивов индв'б—>
—» ксов: (2 9]
§5.4. Изменение (формы массивов
Изменение формы массивов в NumPy позволяет преобразовывать мно-
гомерные массивы, не изменяя их данные. Это полезно, когда нужно изменить
представление данных для удобства обработки или визуализации.
5.4.1. Функция пр.reshape()
Функция пр. reshape() изменяет форму массива, не изменяя его данные.
Синтаксис функции:
Листинг 5.40: Синтаксис функции пр.reshape()
1 пр.reshape(а, newshape, order=’C’, copy=None)
где
• а исходный массив;
• newshape — новая форма массива (например, newshape = (2, 3) для дву-
мерного массива с 2 строками и 3 столбцами);
• order (необязательный) — порядок хранения многомерного массива в па-
мяти (’С’ для строкового, ’F1 для столбцового);
• сору (необязательный) — если True, создается копия массива, если False,
вызывает ValueError. если копирования нельзя избежать. Если None, то
копирование будет сделано только в том случае, если это требуется order.
Создадим одномерный массив и изменим его форму на двумерный массив
с помощью функции пр. reshaped
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем одномерный массив
а = пр аггау([1, 2, 3, 4, 5, 6])
# Изменяем форму на двумерный массив
b = пр reshape(a, (2, 3))
print("Исходный массив:\п", а)
print("Измененный массив :\п", Ь)
я Вывод:
# Исходный массив-
# [1 2 3 4 5 6]
# Измененный массив:
# [[1 2 3]
# [456]]
Листинг 5.41: Изменение формы массива с помощью пр reshape ()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Функция пр.reshaped позволяет легко изменять форму массивов, что
полезно при подготовке данных для машинного обучения или визуализации.
5.4.2. Функция пр.ravel()
Функция пр.ravel() преобразует многомерный массив в одномерный,
сохраняя порядок элементов. Синтаксис функции;
Листинг 5.42: Синтаксис функции пр.ravel О
1 пр.ravel(a, order=’C’)
где
• а исходный многомерный массив;
• order (необязательный) порядок храпения элементов (’С’ для строко-
вого, F' для столбцового).
Создадим двумерный массив и преобразуем его в одномерный с помощью
функции пр. rave 1 ().
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем двумерный массив
а = пр array ([[1, 2, 3], [4, 5, 6]])
# Преобразуем его в одномерный массив
Ь = пр ravel(a)
print("Исходный массив:\п", а)
print("Измененный массив:\п", Ь)
# Вывод:
# Исходный массив:
# [[1 2 3]
# [456]]
# Измененный массив:
# [1 2 3 4 5 6]
Листинг 5.43: Преобразование многомерного массива в одномерный с помощью
функции пр. ravel О
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Функция пр . ravel О полезна для преобразования многомерных масси-
вов в одномерные, что может быть необходимо при подготовке данных для
машинного обучения или визуализации.
5.4.3. Функция np.flattenO
Функция np.flattenO также преобразует многомерный массив в одно-
мерный, но возвращает копию массива, а не представление. Синтаксис функ-
ции:
Листинг 5.44: Синтаксис функции np.flattenO
1 пр.flatten(а, order=’C’)
где
• а исходный многомерный массив;
• order (необязательный) — порядок хранения элементов (’С’ для строко-
вого, ’F’ для столбцового).
Создадим двумерный массив и преобразуем его в одномерный с помощью функ-
ции np.flattenO.
Листинг 5.45: Преобразование многомерного массива в одномерный с помощью
функции np.flattenO
Z '
1 Я Импортируем библиотеку NumPy
2 import numpy as пр
# Создаем двумерный массив
а = пр array ([[1, 2, 3], [4, 5, 6]])
# Преобразуем его в одномерный массив
b = пр flatten(a)
print("Исходный массивАп", а)
print("Измененный массивАп", Ъ)
# Вывод:
# Исходный массив
# [[1 2 3]
# [456]]
и ft Измененный массив:
15 я [1 2 3 4 5 6]
Функция пр. flatten О полезна, когда нужно получить одномерный мас-
сив, но при этом важно сохранить исходный массив без изменений.
§5.5. Универсальные функции (ufunc)
Универсальные функции (ufunc) в NumPy это функции, кото-
рые могут применяться к массивам поэлементно. Они позволяют выполнять
операции над массивами без необходимости использования циклов, что значи-
тельно ускоряет вычисления. Универсальные функции в NuniPy реализованы
с помощью языка С. что обеспечивает высокую производительность и эффек-
тивность благодаря использованию векторизации и параллельных вычислений
Опи могут быть математическими, логическими или другими функциями, ко-
торые работают с массивами NuniPy. Универсальные функции принимают на
вход один пли несколько массивов и возвращают новый массив, содержащий
результаты применения функции к каждому элементу входных массивов.
В таблице 5.1 приведены некоторые из наиболее часто используемых ма-
тематических функций в NuniPy.
Таблица 5.1: Математические функции в NuniPy
Функция Описание
np.add(xl, х2) Сложение зц + х2
пр subtract(xl, х2) Вычитание Xj — ;г2
пр multiply(xl, х2) Умножение ,Т1 • т-2
пр divide(xl, х2) Деление X\Jx2
пр sin(x) Синус
пр.cos(х) Косинус
пр.tan(x) Тангенс
np.arcsin(x) Арксинус
пр arccos(x) Арккосинус
пр arctan(x) Арктангенс
Функция Описание
np.hypot(xl, х2) Гипотенуза прямоугольного треугольника с ка- тетами и .т2 (\/.Г| -t .г^)
пр.degrees(х) Перевод радиан в градусы
пр radians(х) Перевод градусов в радианы
пр arctan2(y, х) Арктангенс от у/х. учитывающий квадранты
пр.sinh(х) Гипсрболичсский синус
пр cosh(x) Гиперболический косинус
np.tanh(x) Гиперболичсский тангенс
пр arcsinh(x) Обратный гиперболический синус
пр arccosh(х) Обратный гиперболический косинус
пр arctanh(x) Обратный гиперболический тангенс
пр round(а, decimals) Округление до указанного количества десятич- ных знаков
пр floor(x) Округление до ближайшего меньшого целого
пр.ceil(x) Округление до ближайшего большего целого
пр trunc(x) Усечение до целого (отбрасывание дробной ча- сти)
пр rint(x) Округление до ближайшего целого (как в round, по возвращает float)
пр fix(x) Аналогично trunc, но возвращает массив того же типа
пр ехр(х) Экспонента в степени х (еж)
пр expml(x) Экспонента в степени х минус 1 (е1 — 1)
пр log(x) Натуральный логарифм (по основанию е)
пр loglO(x) Логарифм по основанию 10
пр log2(x) Логарифм по основанию 2
np.loglp(x) Натуральный логарифм (1 + х)
np.abs(x) Абсолютное значение
пр sqrt(x) Квадратный корень
пр square(х) Возведение в квадрат
пр power(xl, х2) Возведение х1 в степень х2
np.mod(xl, х2) Остаток от деления х! па х2
np.fmod(xl, х2) Остаток от деления х! на х2 (как в С)
Функция Описание
пр remainder(xl, х2) Остаток от деления xl на х2 (как в Python)
пр.паптах(х) Максимальный элемент массива (игнорируя NaN)
пр nanmin(x) Минимальный элемент массива (игнорируя NaN)
пр sign(x) Знак числа (-1, 0 или 1)
пр.heaviside(xl, х2) Функция Хевисайда
пр cbrt(x) Кубический корень
пр reciprocal(х) Обратное значение (1 х)
Указанные функции будут работать поэлементио, что делает их очень
удобными для векторизированных вычислений.
Например, для вычисления синуса каждого элемента массива можно ис-
пользовать функцию np.sinO.
Листинг 5.46: Пример использования универсальной функции np.sinO
1
2
3
4
5
6
7
8
Я
я Импортируем библиотеку NumPy
import numpy as пр
# Создаем массив
х = пр array([0, np.pi/2, пр pi])
я Вычисляем синус каждого элемента массива
у = пр sin(x)
print(у)
# Вывод: [0. 1. 0.]
Универсальные функции в NumPy позволяют легко и эффективно вы-
полнять математические операции над массивами, что делает их мощным ин-
струментом для научных вычислений и анализа данных.
5.5.1. Арифметические операции
Арифметические операции в NumPy являются универсальными функци-
ями, которые позволяют выполнять математические операции над массивами
поэлементно.
В NuniPy арифметические операции можно выполнять двумя способами:
с помощью операторов (таких как +, *, /) и с помощью функций (таких
как np.addO, пр subtract О, пр. multiply О и пр. di videO).
Синтаксис операций аналогичен стандартным арифметическим операци-
ям в Python, по применяется к массивам NuniPy поэлементно.
Листинг 5.47: Арифметические операции в NumPy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Импортируем библиотеку NumPy
import numpy as пр
# Создание массивов
а = пр.array([1, 2, 3])
b = пр.array([4, 5, 6])
# Сложение массивов
с = а + b
# Вычитание массивов
d = а - b
# Умножение массивов
е = а * Ъ
# Деление массивов
f = а / b
# Возведение в степень
g = а ** 2
# Вывод результатов
print ( "Сложениe : " , с) # Выво; [5 7 9]
print ( "Вычитание: ", d) # Вывод: [-3 -3 -3]
print ( "Умножение: " , е) = Вы1= >д 1 4 10 18]
print ( "Деление:" , f) # Вывод: [0.25 0.4 0 5]
print ( "Возведение в степень: " , g) # Вывод: [1 4 9]
Тот же результат можно получить, используя универсальные функции
np.add(), пр.subtract(). пр.multiply() и пр divide() соответственно.
Арифметические операции в NumPy поддерживают как скалярные зна-
чения (числа), так и операции между массивами одинаковой формы. Если мас-
сивы имеют разные формы, NumPy автоматически применяет правила широко-
вещательной совместимости (broadcasting), что позволяет выполнят!, операции
между массивами с разными размерами. Например, если один массив одномер-
ный, а другой двумерный. NumPy будет автоматически расширять одномерный
массив до формы двумерного массива, чтобы выполнить операцию поэлемент-
но. Это позволяет’ легко выполнять операции над массивами разной размерно-
сти без необходимости явного преобразования форм.
Увеличим каждый элемент массива па одно и то же число. Для этого мы
можем сделать это следующим образом:
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем массив
а = пр array([1, 2, 3])
# Добавляем число к каждому элементу массива
b = 2
с = пр add(a, b)
print(c) # Вьэод: [3 4 5]
Листинг 5.48: Пример использования универсальных функций для арифмети-
ческих операций со скаляром
1
2.
3
4
6
7
8
9
В примере выше мы использовали функцию np.addO для добавле-
ния числа 2 к каждому элементу массива а Аналогично можно использовать
другие арифметические функции, такие как пр. subtract О, np.multiplyO
и пр.divide() для вычитания, умножения и деления соответственно.
§ 5.6. Агрегатные функции
Агрегатные функции (или arpei ирующис функции) в NumPy использу-
ются для выполнения операций над массивами, которые сводят (агрегируют)
данные к одному значению или к массиву меньшей размерности. Эти функции
часто используются для вычисления статистических характеристик данных,
таких как сумма, среднее, минимум, максимум и другие. Агрегатные функции
могут применяться к одномерным и многомерным массивам, и они работают
поэлементно, сводя данные к одному значению.
NumPy предоставляет множество агрегатных функций, которые можно
условно разделить на несколько категорий:
• Статистические функции: np.meanO- пр.median(), np.stdO и другие.
• Функции для работы с осевыми значениями: np.sumO, пр. prod О и дру-
гие.
• Логические функции: пр.апуО. np.allO и другие.
Агрегатные функции могут принимать аргумент axis, который позво-
ляет указать, но какой оси нужно выполнять агрегацию. Если axis не указан,
функция будет применена ко всему массиву. Если axis указан, функция будет
применена вдоль указанной оси Например, для одномерного массива агрегат-
ные функции будут работать но всему массиву, а для двумерного массива мож-
но указать axis=0 для агрегации по строкам (по каждому столбцу) или axis=l
для агрегации но столбцам (по каждой строке).
В таблице 5.2 приведены некоторые из наиболее часто используемых аг-
регатных функций в NumPy.
Таблица 5.2: Агрегатные функции в NumPy
Функция Описание
пр.sum(a, axis=None, dtype=None, out=None, keepdims=False) Сумма элементов массива
np.prod(a, axis=None, dtype=None, keepdims=False) Произведение элементов массива
Функция Описание
np.cumsum(a, axis=None, dtype=None, out=None) Кумулятивная сумма элементов мас- сива
np.cumprod(a, axis=None, dtype=None, out=None) Кумулятивное произведение элемен- тов массива
Агрегатные функции в NuniPy позволяют легко и эффективно выпол-
нять операции над массивами, сводя данные к одному значению или к массиву
меньшей размерности.
5.6.1. Статистические функции
Статистические функции в NuniPy позволяют вычислять различные ста-
тистические характеристики данных, такие как среднее, медиана, стандартное
отклонение и другие. Эти функции полезны для анализа данных и получения
сводной информации о массиве.
В таблице 5.3 приведены некоторые из наиболее часто используемых ста-
тистических функций в NuniPy.
Таблица 5.3: Статистические функции в NumPy
Функция Описание
np.mean(a, axis=None, dtype=Non.e, keepdims-False) Среднее арифметическое элементов массива
np.median(a, axis=None, overwrite_input=False, keepdirr.s=False) Медиана элементов массива
np mode(a, axis=None, keepdims=False) Мода (наиболее часто встречающее- ся значение)
np.var(a, axis=None, dtype=None, ddof=0, keepdims=Fa.lse) Дисперсия элементов массива
np std(a, axis=None, dtype=None, ddof=0, keepdims=False) Стандартное отклонение элементов массива
Функция Описание
np.covCa, y=None, rowvar=True, bias-False, ddof=None, fweights=None, aweights=None) Ковариационная матрица
np.corrcoef(x, y=None, rowvar=True, bias-False, ddof=None, fweigiits=l\'one, awei ghts-None) Коэффициент корреляции Пирсона
np.min(a, axis-Nonc, out=None, keepdims=False) Минимальный элемент в массиве
np.inax(a, axis=None, out=None, keepdims=False) Максимальный элемент в массиве
np ptp(a, axis=None, out=None, keepdims=False) Размах (разница между максимумом и минимумом)
np.quantile(a, q, axis=None, overwrite_input=False, interpolation3’linear’, keepdims=False) Квантиль (квантиль q)
np.percentile(a, q, axis=Mone, overwrite,input=False, interpolation3’linear’, keepdin:s=False) Перцентиль (перцентиль q)
np.jqr(a, axis=None, rng=(25, 75), overwrite_input=False, keepdims^False) Интсрквартпльный размах (IQR)
np. arginin(a, axis=None, out=None) Индекс минимального элемента
np.argn.ax(a, axis=None, out=None) Индекс максимального элемента
Функции np.varO и np.stdO имеют параметр ddof, который позволяет
указать степень свободы дчя вычисления дисперсии и стандартного отклоне-
ния. По умолчанию ddof=0, что соответствует смещенным оценкам выборочной
дисперсии и выборочного стандартного отклонения. Если ddof=l. го функции
будут вычислять несмещенную выборочную дисперсию и несмещенное выбо-
рочное стандартное отклонение, что полезно при работе с выборками.
Вычислим среднее, медиану и стандартное отклонение для одномерного
массива с помощью функций NumPy:
Листинг 5.49: Пример использования статистических функций в NumPy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Импортируем библиотеку NurnPy
import numpy as пр
# Создаем массив
data = np.array([l, 2, 3, 4, Ь])
# Вычисляем среднее, медиану и стандартное отклонение
«-э е
mean = пр mean(data)
median = пр.median(data)
std = np.std(data, ddof=0) 4 ddof 0 для смещение i oe-»
-> ценки
# Выводим результаты
print("Среднее:" , mean)
print("Медиана:", median)
print("Стандартное отклонение:", std.round(2)) # 0k<—»
«-> ругляем до двух знаков после запятой
# ^ывод:
й Среднее: 3.0
й Медиана: 30
й Стандартное отклонение: 1.41
5.6.2. Логические функции
Логические функции в NumPy позволяют выполнять поэлементные ло-
гические операции над массивами, включая проверку условий, а также логиче-
ские операции И, ИЛИ. НЕ и исключающее ИЛИ. Эти функции особенно полезны
для фильтрации данных, создания масок, проверки выполнения условий и вы-
полнения векторных логических операций над массивами.
13 таблице 5.4 приведены некоторые логические функции в NumPy, ко-
торые позволяют выполнять логические операции над массивами.
Таблица 5.4: Логические функции в NuniPy
Функция Описание
np any(a, axis=None, out=None, keepdims=False) Возвращает True, если хотя бы один элемент истинный
np all (a, axj.s=None, out=None, keepdims=False) Возвращает True, если все элементы истинные
np.allclose(a, b, rtol=le-05, atol=le-08, equal_nan--False) Проверяет, все ли элементы массивов а и b близки друг к другу с заданной точностью
np.logical_and(xl, x2, out=None) Логическое И для массивов
np.logical_or(xl, x2, out=None) Логическое ИЛИ для массивов
np logical_not(x, out=None) Логическое отрицание для массивов
np logical_xor(xl, x2, out=None) Логическое исключающее ИЛИ для массивов
Логические функции в NuniPy позволяют легко и эффективно выпол-
нять логические операции над массивами, что делает их полезными для филь-
трации данных и проверки условий.
Листинг 5.50: Логическое И для массивов в NurnPy
1 # Импортируем библиотеку NumPy
2 import numpy as np
з
4 # Создание массивов
s a = np.array([True , False, True])
в b = np array([False, False, True])
7
в я Логическое И
э result = пр.lcgical_and(а, Ь) # Вывод IF Ise, <-»
«-э False , True]
Для массива проверим условие «массив содержит' числа больше двух»
с помощью функции пр. any (J.
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем массив
arr = пр.array([1, 2, 3, 4, 5])
# Проверяем, есть ли элементы больше 2
result = пр.any(arr > 2)
print (’’Есть ли элементы больше 2?“, result)
# Вывод: True
Листинг 5.51: Пример использования логических функций в NumPy
1
2
3
4
5
6
7
8
9
§ 5.7. Работа с уникальными значениями и частотой
Функции для работы с уникальными значениями и частотой в NumPy
позволяют находить уникальные элементы в массиве, подсчитывать их количе-
ство и определять частоту появления каждого элемента. Эти функции полезны
для анализа данных, очистки и подготовки массивов перед дальнейшей обра-
боткой.
5.7.1. Функция пр. unique О
Функция пр. unique О используется для нахождения уникальных эле-
ментов в массиве и может возвращать дополнительные сведения, такие как
индексы и количество вхождений каждого уникального элемента.
Синтаксис функции пр. unique О выглядит следующим образом:
Листнн! 5.52: Синтаксис функции np.uniqueO
—
1 np . unique(аг, return_index-Fal.se , <—
> return_inverse = False , return_counts=False , 4-*
с—> axis-None)
где
• ar - входной массив;
• return, index (необязательный) — если True, возвращает индексы первого
вхождения каждого уникального элемента;
• return_inverse (необязательный) если True, возвращает индексы, ко-
торые могут быть использованы для восстановления исходного массива
из уникальных элементов;
• return.counts (необязательный) если True, возвращает количество
вхождений каждого уникального элемента;
• axis (необязательный) — ось, вдоль которой нужно искать уникальные
элементы (по умолчанию None, что означает, что поиск выполняется по
всему массиву).
Например, создадим массив data с повторяющимися элементами и ис-
пользуем функцию np.uniqueO дня нахождения уникальных элементов и под-
счета их количества.
Листинг 5.53: Пример использования функции np.uniqueO
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Массив для демонстрации всех возможностей
data = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])
# Получение всех дополнительных данных
unique.vals, indices, inverse, counts = np.unique(
data ,
return_index=True,
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
return_inverse=True,
return_counts=True
)
print("Исходный массив.:", data)
# Вывод: Исходный массив: [3141592653]
print("Уникальные значения:", unique.vals)
# Вывод: Уникальные значения: [1234569]
print("Индексы первого вхождения ", indices)
# Вывод: Индексы первого вхождения: [1602475]
print("Обратные индексы:", inverse)
# Зывод. Обратные индексы. [2030461542]
print("Количество вхождений:", counts)
# .Вывод: Количество вхождений: [2121211]
# Проверяем восстановление исходное массива
restored = unique_va)s [inverse]
print("Восстановленный массив:", restored) # Ьывол
W Восстановленный массив: [3141592653]
я Проверяем, идентичны ли исходный и восстановленный^
-4 массивы
print ("Массивы идентичны:", np . array_equal (data ,
restored)) # Вы-од: True
5.7.2. Функция пр. bin count ()
Функция пр.bincount() используется для подсчета количества вхожде-
ний каждого неотрицательного целого числа в одномерном массиве. Синтаксис
функции пр. bincount О:
Листинг 5.54: Синтаксис функции пр .bincount()
1 пр.bincount(х, weights=None, minlength^O)
где
• х - входной одномерный массив неотрицательных целых чисел;
• weights (необязательный) массив весов, который позволяет учитывать
частоту появления каждого элемента;
• minlength (необязательный) минимальная длина выходного массива
(по умолчанию 0).
Функция пр. bincount О возвращает массив, где индекс соответствует
значению элемента, а значение в этом индексе количество вхождений этого
элемента в исходном массиве. Если указаны веса, то функция подсчитывает
взвешенное количество вхождений. Если minlength задан, то выходной массив
будет иметь указанную длину, и если количество уникальных элементов мень-
ше. то недостающие индексы будут заполнены нулями.
Например, создадим массив data с неотрицательными целыми числами
и используем функцию пр .bincount () для подсчета количества вхождений
каждого числа.
Листинг 5.55: Пример использования функции пр.bincount()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем массив с неотрицательными целыми числами
data = np.array([0, 1, 2, 2, 3, 3, 3])
# Подсчитываем количество вхождений каждого числа
counts = пр.bincount(data)
print("Количество вхождений каждого числа:", counts)
# ?ывод: Количество вхождений каждого числа: [112 3]
л Используем веса для подсчета частоты
weights = пр.array([1, 2, 1, 1, 1, 1, 1])
weighted_counts = пр.bincount(data, weights=weights)
print("Количество вхождений каждого числа с учетом в^-1
*—> есов • " , we ight ed . count.s )
# Вывод: Количество вхождений каждого числа с учетом^
<-> весов: [1. 2. 2. 3.]
§ 5.8. Работа с NaN и бесконечностью
В библиотеке NumPy предусмотрены специальные значения для пред-
ставления недоступных данных и бесконечности: NaN (Not a Number, не число)
и Inf (бесконечность). Эти значения могут возникать в результате математи-
ческих операций (например, деления на ноль), ошибок вычислений или для
обозначения пропущенных данных.
В таблице 5.5 представлены основные функции и методы NumPy для
работы с NaN и бесконечностью.
Таблица 5.5: Функции для работы с NaN и бесконечностью в NumPy
Функция Описание
np isfinite(x) Проверяет, являются ли элементы конечными числами (не NaN и не бес- конечность)
пр,isnan(x) Проверяет, являются ли элементы NaN (нечисловыми значениями)
пр isinf(х) Проверяет, являются ли элементы бесконечными числами (положитель- ной или отрицательной бесконечно- стью)
пр nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None) Заменяет NaN и бесконечные значе- ния на заданные значения
np.nanmean(a, axis=None, dtype^None, ouc=None, keepd ims=False) Вычисляет среднее значение масси- ва, игнорируя NaN значения
np.nann:edian(a, axis=None, overwrite,input=Fa]se, keepdims=False) Вычисляет медиану массива, игнори- руя NaN значения
np.nanvarta, axis=None, dtype=None, ddof=0, keepdims=False) Вычисляет дисперсию массива, игно- рируя NaN значения
Функция Описание
пр nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False) Вычисляет стандартное отклонение массива, игнорируя NaN значения
np nanquantileta, q, axis=None, overwnte_input=False, interpolation=’linear’, keepdims=False) Вычисляет квантиль массива, игно- рируя NaN значения
np.nanpercentile(a, q, axis=None, overwrite _input=False, interpolation^ linear’, keepdiir.s=False) Вычисляет процентиль массива, иг- норируя NaN значения
np , nanni).n(a, axis=None, out=None, keepdims=False) Находит минимальное значение в массиве, игнорируя NaN значения
npnanmax(a, axis=None, out=None, keepdinis=Fal se) Находит максимальное значение в массиве, игнорируя NaN значения
np nanargminCa, axis=-None, out=None) Находит индекс минимального зна- чения в массиве, игнорируя NaN зна- чения
np,nanargmax(a, axis=None, out=None) Находит индекс максимального зна- чения в массиве, игнорируя NaN зна- чения
np.nanprod(a, axis=None, dtype^None, out=None, keepdims=False) Вычисляет произведение элементов массива, игнорируя NaN значения
Функции для работы с NaN и бесконечностью позволяют эффективно об-
рабатывать данные, содержащие недоступные или бесконечные значения, что
делает их полезными для анализа данных и подготовки массивов перед даль-
нейшей обработкой. Игнорирование NaN значений означает, что эти значения не
будут учитываться при вычислении статистических характеристик, таких как
среднее, медиана, дисперсия и других.
Выясним, содержит ли массив элементы NaN или бесконечность, с помо-
щью функций np. isnan О и пр. isinf ().
Листинг 5.56: 11ример работы с NaN и бесконечностью
1
2
3
4
в
7
8
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем массив с NaN и Inf значениями
а = пр array([1, 2, пр.пап, 4, пр.inf])
» Проверяем наличие NaN значений
print ("Наличие NaN:", пр isnan(a)) ч dubg;: Наличи w
—> NaN: [False False True False False]
# Проверяем наличие Inf значений
print("Наличие Inf:", np.isinf(a)) “ Вывод Наличием
«-» Inf: [False False False False True]
§ 5.9. Сортировка и поиск
Библиотека NumPy предоставляет эффективные функции для сортиров-
ки массивов и поиска элементов. Эти инструменты позволяют упорядочивать
данные, находить индексы элементов и выполнять бинарный поиск в отсорти-
рованных массивах.
5.9.1. Основные функции сортировки и поиска
В NumPy доступны следующие основные функции для работы с сорти-
ровкой и поиском в массивах:
• пр.sort(arr) возвращает отсортированную копию массива arr. Для
многомерных массивов можно указать ось сортировки с помощью пара-
метра axis:
• arr.sort() — сортирует массив па месте (без создания копии). Изменяет
исходный массив;
• np.argsort(агг) — возвращает индексы элементов, которые отсортируют
массив. Это полезно для косвенной сортировки или переупорядочиванпя
других массивов в соответствии с сортировкой;
* np.searchsorted(arr, val) выполняет бинарный поиск в отсортиро-
ванном массиве, возвращая позицию, в которой можно вставить заданное
значение, чтобы сохранить порядок сортировки;
• np.where(condition) возвращает индексы элементов, удовлетворяю-
щих заданному условию condition. Для многомерных массивов возвра-
щает кортеж массивов индексов по каждой оси;
• np.argmax(агг) возвращает индекс максимального элемента в массиве.
Поддерживает параметр axis для поиска по осям;
• пр. argmin(агг) возвращает индекс минимального элемента в массиве.
Также поддерживает параметр axis:
• np.nonzero(агг) возвращает индексы ненулевых элементов массива.
Аналогично пр. where (агг != 0);
• пр 1 exsort (keys) выполняет косвенную сортировку по нескольким
ключам (последовательностям). Полезен для сортировки по нескольким
столбцам данных;
• np.partii;ion(arr, к) выполняет частичную сортировку, разметая
А>й наименьший элемент на правильной позиции, с меньшими элементами
перед ним и большими — после;
• np.argpartition(агг, к) возвращает индексы, которые выполнили
бы частичную сортировку массива. Полезен для нахождения к наимень-
ших/иаибольших элементов без полной сортировки массива.
Приведенные выше функции оптимизированы для работы с большими
массивами данных и поддерживают различные типы данных, что делает их
незаменимыми для задач анализа данных и научных вычислений Большин-
ство функций поддерживает параметр axis, позволяющий указывать ось для
выполнения операции в многомерных массивах. Выбор конкретной функции
зависит от решаемой задачи: нужно ли изменить исходный массив или создать
копию, требуется ли полная сортировка или 'только частичная, нужно ли найти
один элемент пли несколько.
5.9.2. Сортировка массивов
Функция пр. sort () используется для сортировки массива по возраста-
нию пли убыванию. Синтаксис функции:
Листинг 5.57: Синтаксис функции пр.sort()
i
np.sort(a, axis=-l, kind=’quicksort’, order=None)
где
• а — входной массив;
• axis ось. вдоль которой выполняется сортировка (по умолчанию -1. т. с.
последняя ось);
• kind алгоритм сортировки (по умолчанию ’quicksort’);
• order поле, по которому выполняется сортировка (для структурирован-
ных массивов).
Создадим массив data и отсортируем его с помощью функции пр. sort О.
Листинг 5.58: Пример сортировки массива с помощью функции пр.sort()
1 # Импортируем библиотеку NumPy
2 import numpy as пр
4 p Создаем массив
s data = пр.array ([3, 1, 2])
в и Сортируем массив
т sorted_data = пр.sort(data)
в print("Исходный массив:", data)
9 # Вывод: Исходный массив: [3 1 2]
ю print("Отсортированный массив:", sorted.data)
и # Вывод: Отсортированный массив: [1 2 3]
Функция np sortO возвращает новый отсортированный массив, не из-
меняя исходный массив. Если необходимо отсортировать массив ио убыванию,
можно использовать параметр kind с значением ’mergesort’ и затем исполь-
зовать функцию np.flipO для инвертирования порядка элементов.
Листинг 5.59: Сортировка массива по убыванию
1
2
3
4
5
6
7
в
9
10
11
12
13
14
# Импортируем библиотеку NumPy
import numpy as np
# Создаем массив
data = np.array([3, 1, 2])
# Сортируем массив по возрастанию
sorted.data = np sort(data)
# Инвертируем порядок элементов для сортировки по убе-»
<—> ыванию
sorred_data_desc = np.flip(sorted.data)
print("Исходный массив , data)
print("Отсортированный массив по убыванию:", +~
«-> sorted_data_desc)
V Вывод:
Я Исходный массив: [3 1 2]
# Отсортированный массив по убыванию1 [3 2 1]
Функция np sortO также может использоваться для сортировки мно-
гомерных массивов. Если массив многомерный, то сортировка выполняется по
указанной оси. Если ось не указана, то сортировка выполняется по послед-
ней оси. Например, для двумерного массива можно отсортировать элементы по
строкам или столбцам, указав параметр axis.
Выполним сортировку двумерного массива но строкам с помощью функ-
ции up.sort(). Для сортировки по строкам необходимо указать параметр
axis=l.
Листинг 5.60: Сортировка двумерного массива по строкам с помощью функции
np. sortO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
9 Импортируем библиотеку NumPy
import numpy as np
9 Создаем двумерный массив
data = np. array ([ [3, 1, 2], [6, 4, 5]])
9 Сортируем массив по строкам
sorted.data = np.sortCa, axis=l)
print("Исходный массив:")
print(data)
print("Отсортированный массив по строкам:")
print(sorted_datа)
# Зывод:
# Исходный массив:
9 CL3 1 2]
9 [64 5]]
9 Отсортированный массив по строкам:
9 [[1 2 3]
9 [456]]
Выполним сортировку двумерного массива по столбцам с помощью
функции np. sort О. Для сортировки по столбцам необходимо указать пара-
метр axis-0
Листинг 5.61: Сортировка двумерного массива по столбцам с помощью функции
np. sortO
9 Импортируем библиотеку NumPy
import numpy as np
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
» Создаем двумерный массив
data = пр.array([[3, 1, 2], [6, 4, 5]])
# Сортируем массив по столбцам
sorted„data = np.sort(a, axis=0)
print("Исходный массив:")
print(data)
print("Отсортированный массив по столбцам:")
print(sorted_data)
# Вывод:
# Исходный массив:
# [[3 1 2]
# [64 5J]
# Отсортированный массив по столбцам’
# [[312]
# [645]]
5.9.3. Поиск индексов отсортированных элементов
Функция пр. argsort О возвращает индексы элементов массива в поряд-
ке их сортировки. Синтаксис функции:
Листинг 5.62: Синтаксис функции пр.argsort()
1 пр argsort(a, axis=-l, kind=’quicksort’, order=None)
где
• а входной массив;
• axis — ось. вдоль которой выполняется сортировка (ио умолчанию -1. т. е.
последняя ось);
• kind — алгоритм сортировки (ио умолчанию ’quicksort’);
• order — поле, по котором)' выполняется сортировка (для структурирован-
ных массивов).
Найдем индексы отсортированных элементов в одномерном массиве data
с помощью функции np.argsort().
Листинг 5.63: Пример поиска индексов отсортированных элементов
1 # Импортируем библиотеку NumPy
2 import numpy as np
з
4 # С.здаек массив
s data = np.array ([3, 1, 2])
e # Получаем индексы отсортированных элементов
т sorted.indices = np.argsort(data)
s print ("Исходный массив:", data) # Вы- од: Исход: ай мн
ассив : [3 12]
э print("Индексы отсортированных элементов:", <—
sorted.indices)
ю # Вывод: Индексы отсортированных элементов: [1 2 0]
5.9.4. Бинарный поиск
Функция np searchsortedO выполняет бинарный поиск по отсортиро-
ванному массиву и возвращает индекс, по которому следует вставить заданное
значение, чтобы сохранить порядок сортировки.
Синтаксис функции:
Листинг 5.61: Синтаксис функции np.searchsortedO
1 пр.searchsorted(а, v, side=’left’, sorter=None)
где
• а отсортированный входной массив;
• v значение для поиска;
• side — сторона, с которой следует искать (по умолчанию ’left’);
• sorter массив индексов, который сортирует а (по умолчанию None).
Выполним бинарный поиск значения 3 в одномерном массиве data с по-
мощью функции np.searchsortedO.
Листинг 5.65: Пример бинарного поиска в одномерном массиве с помощью
функции np.searchsortedO
1 # Импортипу^м библиотеку NumPy
2 import numpy as np
3
4 # Создаем отсортированный массив
s data = np.array([1, 2, 3, 4, 5J )
6 9 Выполняем бинарный поиск
7 index = np.searchsorted(data, 3)
s print("Исходный массив:", data)
9 # Внвод: Исходный массив: [12345]
iu print ("Индекс для вставки 3:", index)
и # Вывод: Индекс для вставки 3: 2
Функция np searchsortedO может использоваться для поиска индек-
сов, по которым следуют вставить несколько значений.
Листинг 5.66: Пример бинарного поиска в одномерном массиве для нескольких
значений с помощью функции np.searchsortedO
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Создаем отсортированный массив
data = np.array([1, 2, 3, 4, 5])
# Выполняем бинарный поиск
indices = np.searchsorted(data, [2, 3, 5])
print("Исходный массив:", data)
# Вывод: Исходный массив: [12345]
ю
и
print("Индексы для вставки [2, 3, Б]:", indices)
# Вывод: Индексы для вставки [2, 3, 5]: [12 4]
Для многомерных массивов функция пр. searchsortedO может исполь-
зоваться для поиска индексов по заданной осп. Дэя этого необходимо указать
ось с помощью параметра axis, вдоль которой выполняется поиск.
Выполним бинарный поиск значения 2 для двумерного массива data
вдоль второй оси (по строкам) с помощью функции пр.searchsortedO. Для
этого необходимо указать ось с помощью параметра axis=l
Листинг 5.67: Пример бинарного поиска в двумерном массиве с помощью функ-
ции пр. searchsortedO
1
2
3
4
5
6
7
8
9
10
И
12
13
14
15
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем двумерный отсортированный массив
data = пр аггау([[1, 2, 3], [4, 5, 6]])
# Выполняем бинарный поиск по первой строке
index = пр.searebsorted(data [0] , 2)
print("Исходный массив ")
print(data)
print("Индекс для вставки 2 в первой строке:", index)
# ?ывод:
# Исходный массив:
# [[1 2 3]
# [4 5 6]]
И Индекс для вставки 2 в первой строке. 1
5.9.5. Функция np. where О
Функция пр where О используется для поиска индексов элементов, удо-
влетворяющих определенному условию, и для замены значений в массиве. Син-
таксис функции:
Листинг 5.68: Синтаксис функции np.where()
1 пр.where(condition , x = None , y = None)
где
• condition условие, которое должно быть выполнено (массив логиче-
ских значений);
• х (необязательный) значение, которое будет возвращено, если условие
выполняется:
• у (необязательный) значение, которое будет возвращено, если условие
нс выполняется.
Функция np.where() может использоваться в двух режимах:
• Если параметры хну не указаны, она возвращает индексы элементов,
удовлетворяющих условию.
• Если параметры х и у указаны, она возвращает новый массив, где эле-
менты, удовлетворяющие условию, заменяются па х, а остальные — на
У-
Выясним индексы элементов в одномерном массиве, удовлетворяющих
условию, с помощью функции np.where().
Листинг 5.69: Пример использования функции np where () для поиска индексов
в одномерном массиве
—
1 # Импортируем библиотеку NuniPy
2 import numpy as np
3
4
5
б
7
8
9
10
11
# Создаем одномерный массив
агг = пр.аггау([1, 2, 3, 4, 5])
# Определяем условие
condition = агг > 2
я Получаем индексы элементов, удовлетворяющих условие—
> ю
indices = np.where(condition)
print(’Индексы элементов, удовлетворяющих условию^
<—> : ’ , indices )
# Вывод: Индексы элементов, удовлетворяющих условию<->
—> (аггау([2, 3, 4] , dtype=int64) ,)
Выясним индексы элементов в двумерном массиве, удовлетворяющих
условию, с помощью функции np.where().
Листинг 5.70: Пример использования функции np.where() для поиска индексов
в двумерном массиве
/ >
1 # Импортируем библиотеку NumPy
2 import numpy as np
з
4 # С.здаем двумерный массив
s arr_2d = np.array ([[1 , 2, 3], [4, 5, 6], [7, 8, 9]])
о # Определяем условие
т condition_2d = arr_2d > 5
s # Получаем индексы элементов, удовлетворяющих условий—'
—> ю
9 indices_2d = np.where(condition.2d)
io print (’Индексы элементов, удовлетворяющих условию в <—>
=—> двумерном массиве:’, indices,2d)
п # Вывод: Индексы элементов, удовлетворяющих условию 4-»
в двумерном массиве (array(Ll, 2, 2, 2], «-»
‘ » dtype=int64), array([2, 0, 1, 2], dtype=int64))
Выполним замену значений в одномерном массиве, удовлетворяющих
условию, на заданное значение с помощью функции пр. where О.
Листинг 5.71: Пример замены значений в одномерном массиве с помощью функ-
ции пр.where()
/-----------------------------------------------------------
1 # Импортируем библиотеку NumPy
2 import numpy as пр
з
4 # Создаем идни.мерный массив
s arr = пр.array([1, 2, 3, 4, 5])
в # Определяем условие
7 condition = arr > 2
s # Заменяем элементы, удовлетворяющие условию, на О
э arr = пр.where(condition , 0, arr)
io print (’ Массив после замены:’, arr)
п # Вывод: Массив после замены: [12000]
Выполним замену значений в двумерном массиве, удовлетворяющих
условию, на заданное, значение с помощью функции пр. where().
Листинг 5.72: Пример замены значений в двумерном массиве с помощью функ-
ции пр.where()
—
1 # Импортируем библиотеку NumPy
2 import numpy as пр
3
4 # Создаем двумерный массив
s arr_2d = пр.array(Г[1, 2, 3], [4, 5, 6], [7, 8, 9]])
о # Определяем условие
7 condition_2d = arr_2d > 5
s # Заменяем элементы, удовлет оряюшие условию, на 0
э # (элементы, не удовлетворяющие условию, остаются бе<-^
—т з изменений)
ю arr_2d = пр.where(condition_2d , 0, arr_2d)
п print(’Массив после замены:’, arr_2d)
12
13
14
# Вывод: Массив после замены: [[1 2 3]
# [450]
# [ООО]]
§ 5.10. Объединение массивов
Объединение массивов в NuniPy позволяет комбинировать массивы. Это
делает их полезными ,зля анализа данных и подготовки массивов перед даль-
нейшей обработкой. NuniPy предоставляет функции для объединения массивов
вдоль заданной оси. Основные функции для объединения массивов включают:
• np.concatenate() объединяет несколько массивов вдоль заданной оси;
• пр. st ack () — объединяет массивы вдоль новой оси;
• пр hstackO объединяет массивы по горизонтали (вдоль оси 1);
• np.vstackO объединяет массивы по вертикали (вдоль оси 0);
• np.dstackO объединяет массивы ио глубине (вдоль оси 2).
5.10.1. Функция np. con catenate ()
Функция пр . concatenate О используется для объединения нескольких
массивов вдоль заданной осп. Синтаксис функции
Листинг 5.73: Синтаксис функции np. concatenate О
1 пр.concatenate((al, а2 , . ..), axis=0, out = None)
где
• al, а2, ... массивы, которые нужно объединить.
• axis ось, вдоль которой выполняется объединение (но умолчанию 0);
• out (необязательный) массив, в который будет записан результат объ-
единения;
• dtype (необязательный) тип данных выходного массива.
Объединим два одномерных массива с номошыо функции
np.concatenate()
Листинг 5.71: Пример объединения массивов
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as up
# Создаем два одномерных массива
а = np.array([1, 2, 3])
b = пр.array(|4, 5, 6])
# Объединяем массивы
с = пр concatenate((а , Ъ))
print("Объединенный массив:", с) # ывод Объ, дин н<—•
— f ый массив: [1 2 3 4 5 6]
Объединим два двумерных массива с помощью функции
пр.concatenateO. Для этого необходимо указать в параметре axis ось. вдоль
которой выполняется объединение. Для двумерных массивов ось 0 соответству-
ет строкам, а ось 1 — столбцам.
Листинг 5.75: Пример объединения двумерных массивов
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Создаем два двумерных массива
а = np array([[1, 2], [3, 4]])
b = пр аггау([[5, 6], [7, 8]])
# Объединяем массивы по строкам (ось 0)
с = пр concatenate((а, b) , axis=0)
print("Объединенный массив:", с)
10
11
12
13
14
# Вывод: Объединенный массив:
# [[1 2]
# [3 4]
# [5 6]
# [7 8 ! J
Объединим два двумерных массива ио столбцам с помощью функции
np concatenate(). Для этого необходимо указать в параметре axis ось 1.
Листинг 5.76: Пример объединения двумерных массивов по столбцам
1
2
3
4
5
6
7
Я
9
10
11
12
# Импортируем библиотеку NumPy
import numpy as np
# Создаем два двумерных массива
а = np array([[1, 2], [3, 4]])
b = пр array ([[5, 6], [7, 8]])
# Объединяем массивы по столбцам (ось 1)
с = пр.concatenate((а , b), axis = l)
print("Объединенный массив:", с)
# Вывод: Объединенный массив:
#[[125 6]
# [3478]]
5.10.2. Функции пр. stackO, пр.hstackО и пр vstackO
Для объединения многомерных массивов можно использовать функцию
пр. stackO, которая позволяет объединять массивы вдоль новой оси. Синтак-
сис функции:
Листинг 5.77: Синтаксис* функции пр.stackO
1 пр stack(arrays, axis=0, out=None)
где
• arrays последовательность массивов, которые нужно объединить;
• axis - ось. вдоль которой выполняется объединение (по умолчанию 0);
• out (необязательный) — массив, в который будет записан результат.
Объединим два двумерных массива с помощью функции np.stackO.
Листинг 5.78: Пример объединения многомерных массивов с помощью функции
пр.stack()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем два двумерных массива
а = пр array([[1, 2], [3, 4]])
b = пр array([(5, 6], [7, 8]])
# Объединяем массивы вдоль новой оси
с = np.stack((a, b), axis=0)
print("Объединенный массив:", с)
# Вквод: Объединенный массив.
# [[[1 2]
# ГЗ 4]]
# [[5 6]
# [78]]]
Функция np.stackO позволяет объединять массивы вдоль повой оси,
что может быть полезно для создания многомерных массивов из двумерных
или одномерных массивов.
Функции np.hstackO и np.vstackO также могут использоваться для
объединения массивов по горизонтали (по оси 1) и вертикали (по осп 0) соот-
ветственно. Синтаксис функции np.hstackO
Листинг 5.79: Синтаксис функции np.hstackO
1 пр.bstack(tup , dtype = None, casting=’same_kind ’)
7G
Синтаксис функции np.vstackO:
Листинг 5.80: Синтаксис функции np.vstackO
i np . vstack(tup , dtype=None, casting=’same.kind’)
где
• tup кортеж или список массивов, которые нужно объединить;
• dtype тин данных, который будет использоваться для объединенного
массива (но умолчанию None);
• casting правила приведения типов (по умолчанию ’same .kind’).
Объединим два одномерных массива ио вертикали с помощью функции
np.vstackO.
# Импортируем библиотеку NumPy
import numpy as np
# Создаем два одномерных массива
а = np array([1, 2, 3])
b = пр.array([4, 5, 6])
# Объединяем массивы по вертикали
с = пр vstacke((a, b))
print("Объединенный массив:", с)
# Вывод: '1бъединенный массив:
# [[1 2 3]
# [456]]
Листинг 5.81: Пример объединения одномерных массивов по вертикали с помо-
щью функции np.vstackO
1
2
3
4
6
7
Я
9
10
11
12
Объединим два двумерных массива ио горизонтали с помощью функции
np.hstackO.
# Импортируем библиотеку NuniPy
import numpy as np
# Создаем два двумерных массива
а = np array ([[1, 2], [3, 4]])
b = np array ([[5, 6] , [7, 8] J )
# Объединяем массивы по горизонтали
с = np hstack((a, b))
print("Объединенный массив:", с)
# Вывод: Объединенный массив*
#[[125 6]
# [3478]]
Листинг 5.82: Пример объединения двумерных массивов по горизонтали с по-
мощью функции np.hstack()
1
2
3
«I
5
6
7
8
Ч
10
11
12
Объединим два многомерных массива ио вертикали с помощью функции
np. vstackO,
# Импортируем библиотеку NumPy
import numpy as np
# Создаем два трехмерных массива
а = np.array([[[1, 2], [3, 4]]])
b = пр.array ( [ [ [5 , 6], [7, 8]]])
# Объединяем массивы по вертикали
с = пр.vstack((а, Ь))
print("Объединенный массив:’*, с)
# Вывод: Объединенный массив:
# [[[1 2]
# [34]]
# [[5 6]
# [78]]]
Листинг 5.83: Пример объединения многомерных массивов по вертикали с по-
мощью функции np.vstackO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ 5.11. Разделение массивов
Разделение массивов в NuniPy позволяет разбивать массивы па несколь-
ко частей вдоль заданной осп или но заданным индексам.
5.11.1. Функция пр. split О
Функция пр. split () используется для разделения массива па несколько
частей вдоль заданной оси. Синтаксис функции:
Листинг 5.84: Синтаксис функции пр. split О
1 пр.split(ary, indices_or_sections , axis-0)
где
• ary — массив, который нужно разделить;
• indices_or_sections количество частей или индексы, по которым нуж-
но разделить массив;
• axis ось, вдоль которой выполняется разделение (по умолчанию 0).
Синтаксис функции пр. split О позволяет указать количество частей, на
которые нужно разделить массив, или индексы, по которым нужно разделить
массив. Если указано количество частей, то массив будет разделен на равные
части. Если указаны индексы, то массив будет разделен но этим индексам.
Разделим одномерный массив на 3 части с помощью функции
пр split!).
Листинг 5.85: Пример разделения одномерного массива с помощью функции
пр.split!)
—
1 # Импортируем библиотеку NumPy
2 import numpy as пр
3
4
5
6
7
8
# Создаем одномерный массив
а = пр аггау([1, 2, 3, 4, 5, 6])
# Разделяем массив на 3 части
b = пр . spl it (а , 3)
print ("Разделенный массив:", Ъ) # Вы: од Разд. пенный^
с—> массив: [аггау([1, 2]), array ( [3 , 4]), '
w array([5, 6])]
Разделим двумерный массив на 3 части по строкам с помощью функции
np. split(). Для этого необходимо указать в параметре axis ось 0.
Листинг 5.86: Пример разделения двумерного массива по строкам с помощью
функции np split()
1
2
3
4
6
Т
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Создаем двумерный массив
а = np array([[l, 2], [3 , 4], [5, 6]])
# Разделяем массив на 3 части по строкам
b = np split(a. 3, axis=0)
print("Разделенный массив:", b)
# Вывод: Разделенный массив: [array ([[1, 2]]),
—> аггау([[3, 4]]), аггау([[5, 6]])]
Разделим двумерный массив по индексам с помощью функции
np. split О. Для этого необходимо указать индексы, по которым нужно раз-
делить массив.
Листинг 5.87: Пример разделения двумерного массива по индексам с помощью
функции np.split()
—
1 # Импортируем библиотеку NumPy
2 import numpy as np
3
4
5
е
7
8
9
# Создаем двумерный массив
а = np array ([[1, 2], [3, 4], [5, 6]])
# Разделяем массив по индексам
b = np.splitfa, [1, 3])
print("Разделенный массив.", Ъ)
# Вывод: Разделенный массив: [аггау([[1, 2]]),
«-> array([[3, 4J , [5, 6]]), array([], shape = (O, 2),
w dtype-int32)]
5.11.2. Функции np.hsplitO, np.vsplitO и np dsplitO
Для разделения многомерных массивов можно использовать функцию
np hsplit О • пр vsplit О и пр.dsplit О, которые позволяют разделять масси-
вы по горизонтали (по столбцам), вертикали (по строкам) и глубине (по третьей
оси) соответственно. Синтаксис функции np.hsplitO'
Листинг 5.88: Синтаксис функции np.hsplitO
/-------------------------------------------------------------
1 np hsplit(ary, indices_or_sections)
Синтаксис функции np.vsplitO:
Листинг 5.89: Синтаксис функции np.vsplitO
Z
1 пр.vsplit(ary , indiсеs_or.sect ions )
Синтаксис функции пр.dsplitО:
Листинг 5.90: Синтаксис функции пр.dsplitО
1 пр.dsplit(ary, indices_or_sections)
где
• агу массив, который нужно разделить;
• inch ces_or_sections количество частей или индексы, по которым нуж-
но разделить массив.
Выполним горизонтальное разделение двумерного массива с помощью
функции пр hsplit О:
Листинг 5.91; Пример горизонтального разделения двумерного массива с помо-
щью функции np.hsplitO
1
2
3
4
5
Ь
7
8
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем двумерный массив
а = пр array ([[1, 2], [3, 4], [5, 6]])
# Разделяем массив на 2 части
b = пр hsplit (а, 2)
print("Разделенный массив-", Ъ)
# Вывод: Разделенный массив: [array([[l], L3] , 4-^
- 4 [51]) , array ([[2] , [4] , [6]])]
Выполним вертикальное разделение двумерного массива с помощью
функции np.vsplitO:
Листинг 5.92: Пример вертикального разделения двумерного массива с помо-
щью функции np.vsplitO
1
2
3
4
5
6
7
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем двумерный массив
а = пр.array([[1, 2], [3, 4], [5, 6]])
# Разделяем массив на 2 части
Ъ = пр.vsplit(а , 2)
s print("Разделенный массив;", Ъ)
а # Вывод: Разделенный массив: [аггау([[1, 2]]),
с—> array ([[3, 4], [5, 6]])]
Выполним разделение многомерного массива по глубине с помощью
функции np.dsplitO.
Листинг 5.93: Пример разделения многомерного массива по глубине с помощью
функции np.dsplitO
1
2
3
4
5
6
7
8
9
» Импортируем библиотеку NumPy
import numpy as np
# Создаем трехмерный массив
a = np.array([[ [1 , 2], [3, 4]], [[5, 6], [7, 8]]])
# Разделяем массив на 2 части по глубине
b = np dsplit(а, 2)
print("Разделенный массив ", Ь)
# Вывод: Разделенный массив: [array([[[l, 2]], [С5,
6]]]), агг*у([[[3, 4]], [[7, 8]]])]
§5.12. Преобразование массивов
Преобразование массивов в NumPy позволяет изменять форму, размер-
ность и структуру массивов. NumPy предоставляет функции для изменения
формы массивов, добавления и удаления осей, а также для преобразования
многомерных массивов в одномерные и наоборот.
5.12.1. Изменение формы массива
Функция np. reshape О используется для изменения формы массива без
изменения его данных Синтаксис функции:
Листинг 5.94: Синтаксис функции np.reshapeQ
1 np.reshape(а , neushape , order=’C’)
где
• а — массив, который нужно изменить;
• newshape — новая форма массива;
• order порядок, в котором элементы массива будут располагаться в но-
вой форме (по умолчанию ’С’ — по строкам).
Изменим форму массива с помощью функции np reshape О.
Листинг 5.95: Пример изменения формы массива с помощью функции
np.reshape()
1 # Импсртируем библиотеку NumPy
2 import numpy as np
з
4 # Создаем одномерный массив
s а = np array([l, 2, 3, 4, 5, 6])
в # Изменяем форму массива на 2x3
7 Ь = np.reshape(а, (2, 3))
s print("Исходный массив:", а)
э # Вывод: Исходный массив: [123456]
ю print("Измененный массив:", Ь)
п # Вывод: Измененный массив: [[1 23] [45 6]]
Замечание 2. При изменении формы массива с помощью функции
np. reshape () необходимо, чтобы количество элементов в исходном массиве сов-
падало с количеством элементов в новой форме. Если это не так. будет вызвано
исключение ValueError
5.12.2. Добавление и удаление осей
Функция np.expand_dims() используется для добавления новой оси
в массив. Синтаксис функции:
Листинг 5.96: Синтаксис функции пр.expand_dims()
1 пр.expand_dims(а, axis)
где
• а массив, в который нужно добавить новую ось;
• axis ось. вдоль которой будет добавлена новая ось.
Добавим новую ось массиву с помощью функции np.expand_dims().
Листинг 5.97: Пример добавления новой оси с помощью функции
пр.expand_dims()
✓
1 # Импортируем библиотеку NumPy
2 import numpy as пр
з
# Создаем одномерный массив
s а = пр.array([1, 2, 3])
6 # Добавляем новую ось
т b = пр.expand^dims(а, axis-=0)
з print("Исходный массив ", а)
а # "ывод: Исходный массив: [1 2 3]
ю print("Массив с новой осью:", Ь)
п & Вывод: Масси! с новой осью [[1 2 3]]
Функция пр newaxis также может использоваться для добавления новой
оси в массив.
5.12.3. Удаление осей
Функция np.squeeze() удаляет из массива оси размерности 1, уменьшая
его размерность.
Синтаксис функции:
Листинг 5.98: Синтаксис функции np.squeezeO
1 пр.squeeze(а, axis^None)
где
• а — массив, из которого нужно удалить оси размерности 1;
• axis (необязательный) ось, которую нужно удалить (если нс указано,
удаляются все оси размерности 1).
Удалим ось размерности 1 из двумерного массива с помощью функции
пр squeeze О
Листинг 5.99: Пример удаления осей размерности 1 с помощью функции
пр.squeeze()
1
2
3
4
5
6
7
8
9
10
11
12
# Импортируем библиотеку NumPy
import numpy as np
# Создание массива с осью размерности 1
агг = пр.array([[L1, 2, 3]]])
print("Исходный массив;")
print(агг)
print("Форма массива:", arr.shape)
# Вывод: Форма массива (1, 1, 3)
# Применение функции пр.squeeze О
squeezed_arr = пр squeeze(агг)
print ("Массив после применения np.squeezeO:", «—
squeezed_arr)
13
14
15
ИС
1
1
2
3
4
5
6
7
8
9
10
# Вывод: Массив после применения пр.squeeze(): [1 2 3]
print("Форма массива:", squeezed_arr.shape)
# Вывод: Форма массива: (3,)
§5.13. Копирование массивов
Функция пр.сору() используется дтя создания копии массива. Синтак-
фупкции:
Листинг 5.100: Синтаксис функции пр. сору О
пр.сору(а, order=’K’)
где
* а массив, который нужно скопировать;
• order порядок, в котором элементы массива будут располагаться в ко-
пии (по умолчанию ’К’ сохраняет порядок исходного массива).
Создадим копию массива с помощью функции пр.соруО:
тинг 5.101: Пример копирования массива с помощью функции пр.соруО
X
й Импортируем библиотеку NumPy
import numpy as пр
# Создаем массив
а = пр.array([1, 2, 3])
я Создаем копию массива
Ъ = пр сору(а!
print("Исходный массив:", а)
print ("Копия массива:1’, Ь) # Вывод: [1 2 3]
# Изменяем копию
11
12
13
14
15
b[0] = 10
print("Измененный массив ", Ь)
# Вывод: Измененный массив: [10 2 3]
print("Исходный массив после изменения копии:", а)
# Бывод: Исходный массив после изменения копии: [1
2 3]
Замечание 3. При копировании массива с помощью функции пр.сору О со-
здается новый массив, который по связан с исходным массивом. Изменения
в копии не влияют на исходный массив.
§5.14. Линейная алгебра с библиотекой NumPy
Линейная алгебра является основой многих областей, таких как научные
вычисления, обработка данных и машинное обучение, где операции с матри-
цами и векторами играют ключевую роль. Библиотека NuniPy предоставляет
удобные инструменты для работы с многомерными массивами, что делает се
идеальным выбором для выполнения операций линейной алгебры. С помощью
NuniPy можно эффективно выполнять такие операции, как умножение матриц,
вычисление определителей, нахождение обратных матриц и решение систем ли-
нейных уравнений. Отмстим, что многие вычисления будут численными, это
означает, что результаты могут быть приближены с некоторой степенью точно-
сти.
Подробнее о линейной алгебре в NumPy можно узнать в официальной
документации: https://numpy.org/doc/stable/relerence/routines.linalg.
html.
5.14.1. Задание матриц и векторов
Для создания матриц и векторов в NumPy используются мно-
гомерные массивы, где матрица представляется как двумерный массив,
а вектор — как одномерный массив. Вектор-строка представляет собой одно-
мерный массив, а вектор-столбец двумерный массив с одной колонкой, но
для корректных операций в линейной алгебре важно различать вектор-строкп
(матрицы размера 1 х п) и вектор-столбцы (матрицы размера п х 1).
Создадим матрицу Л размера 2 х 3 с помощью функции np. array О.
Листинг 5.102: Пример создания матрицы размера 2 х 3 с помощью функции
np.array()
Z----------------------------------------------------------
1 # Импортируем библиотеку NumPy
2 import numpy as np
з
4 » Создаем двумерный массив
s а = np.array([[1, 2, 3], L4 , 5, 6J ] )
6 print("Матрица А ", а)
т # Вывод: Матрица А. [[1 2 3]
з # [4 5 6]]
э print("Размеры матрицы A:", a.shape)
ю # Вывод: Размеры матрицы А: (2, 3)
Создадим вектор-строку b размера 1 х 3 с помощью функции np. array ().
Листинг 5.103: Первый способ создания вектора-строки размера 3 с помощью
функции np. array ()
i
2
3
4
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Создаем вектор-строку
b = np array([1, 2, 3])
print("Вектор b:", b)
# Вывод: Вектор b: [1 2 3]
print("Размеры вектора b", b shape)
# Зывод: Размеры вектора b: (3,)
Первый способ создания вектора-строки b размера 1x3 заключает-
ся в создании одномерного массива, который будет интерпретироваться как
вектор-строка. Может вызвать неоднозначность при умножении матриц, так
как NumPy будет считать ого одномерным массивом.
Второй способ создания вектора-строки b размера 1 х 3 заключается
в создании двумерного массива с одной строкой.
Листинг 5.104: Второй способ создания вектора-строки размера 3 с помощью
функции пр arrayО
1
2
3
4
5
6
7
в
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем вектор-строку
b = пр.array([L1, 2, 3]])
print("Вектор b: " , Ь)
И Вывод: Вектор b: [[1 2 3]]
print("Размеры вектора b:", b shape)
# Вывод: Размеры вектора b: (1, 3)
Для создания вектора-столбца b размера 3x1 используется построч-
ное создание двумерного массива с одним столбцом с помощью функции
пр array().
Листинг 5.105: Пример создания вектора-столбца с помощью функции
пр.array()
1 # Импортируем библиотеку NumPy
a import numpy as пр
з
4 # Создаем вектор-столбец
з b = пр аггау([[1], [2], [3]])
с print("Вектор Ь:", Ь)
7 # Вывод: Вектор b: [[1]
в # [2]
9 # [3]]
ю print("Размеры вектора Ь ", b.shape)
и # Вывод: Форма вектора Ь: (3, 1)
Замечание 4. В NuniPy вектор-строка и вектор-столбец представляются как
двумерные массивы, ио с разными размерами. Вектор-строка имеет размер-
ность 1 х п, а вектор-столбец — п х 1. Это важно учитывать при выполнении
операций линейной алгебры, таких как умножение матриц и векторов.
Замечание 5. Библиотека NumPy имеет метод создания векторов и матриц
с помощью функции np.matrix(), который является подклассом np.ndarray.
Однако, он имеет ряд ограничений и может привести к путанице. Рекомен-
дуется использовать стандартные многомерные массивы np. ат ray () для всех
случаев. Подробнее о работе с матрицами в NuniPy, созданными с помощью
np.matnxO, можно узнать в документации https ://numpy.org/doc/stable/
reference/generated/numpy.matrix html.
5.14.2. Транспонирование матриц
Для транспонирования матриц в NuniPy используется функция
np transpose() или метод Т для многомерных массивов. Транспонирование
матрицы означает замену строк на столбцы и наоборот, что позволяет изме-
нить ориентацию данных в матрице.
Синтаксис функции np. transpose ().
Листинг 5.106: Синтаксис функции np.transposeQ
1 пр.transpose(а, axes-None)
где
• а массив, который нужно транспонировать;
• axes (необязательный) оси, по которым выполняется транспонирование
(по умолчанию None, т. е. меняются местами все оси).
Траснонируем матрицу А с помощью функции np. transpose О.
Листинг 5.107: Пример транспонирования матрицы
1
2
3
4
в
7
8
9
10
11
12
13
14
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу A
a = np array([[1, 2, 3], [4, 5, 6]])
# Транспонируем матрицу A
b = np transpose(a)
print("Исходная матрица:", a)
print("Транспонированная матрица ", b)
# Выьэд: Исходная матрица: [[1 2 3]
# [4 5 6]]
И Транспонированная матрица: [[1 4]
# [2 Ь]
# [3 6]]
Также можно использовать метод Т для транспонирования матрицы. При
этом результат транспонирования матрицы А задается с помощью кода b =
а.Т
5.14.3. Сложение матриц
Для сложения матриц в NumPy используется оператор + или функция
np add О Матрицы должны иметь одинаковые размеры, иначе будет вызва-
но исключение ValueError. При этом библиотека NumPy поддерживает ши-
роковещательное (broadcasting) сложение, что позволяет складывать матрицы
разного размера, если одна из них является вектором-строкой или вектором-
столбцом. Также этот механизм распространяется на скаляры (числа), которые
могут быть добавлены к каждому элементу матрицы.
Выполним сложение матриц А и 13 с помощью оператора +:
Листинг 5.108; Пример сложения матриц с помощью оператора +
1 # Импортируем библиотеку NumPy
2
3
4
3
6
7
8
9
10
import numpy as пр
й Создаем матрицы А и В
А = пр array ([[1, 2, 3], [4, 5, 6]])
В = пр.array([[7, 8, 9], [10, 11, 12]])
# Складываем матрицы А и В
С = А + В
print ("Результат сложения матриц А и В.:", С)
# Вывод: Результат сложения матриц А и В: [ [ 8 10 12]
# [14 1G 18]]
Тот же результат мы получим e помощью функции пр. add О. При этом
результат сложения матриц А п В задается с помощью кода С = пр. add (А, В)
Увеличим каждый элемент матрицы Л па число (скаляр) 3 с помощью
оператора +.
Листинг 5.109: Пример сложения матрицы с числом с помошыо оператора +
1 # Импортируем библиотеку NumPy
2 import numpy as пр
з # Создаем матрицу А
4 А = пр аггау([[1, 2, 3], [4, 5, 6]])
з # Увеличиваем каждый элемент матрицы А на 3
6 В = А + 3
т print("Результат сложения матрицы А и числа 3:", В)
$ # Вывод: Результат сложения матрицы А и числа 3: [[
£-э 4 5 6]
9 # [ <-
-э 7 8 9]]
Тот же результат мы получим с помощью функции пр. add О. При
этом результат сложения матрицы А и числа 3 задается с помощью кода
В = пр.add(А, 3)
5.14.4. Вычитание матриц
Для вычитания матриц в NumPy используется оператор — пли функция
np. subtract (). Матрицы должны иметь одинаковые размеры, иначе будет вы-
звано исключение ValueError. При этом библиотека NuniPy поддерживает ши-
роковещательное (broadcasting) вычитание, что позволяет вычитать матрицы
разного размера, если одна из них является вектором-строкой или вектором-
столбцом. Также этот механизм распространяется на скаляры (числа), которые
могут быть вычтены из каждого элемента матрицы.
Выполним вычитание матриц А и В с помощью оператора -.
Листинг 5.110: Пример вычитания матриц с помощью оператора-
1
2
3
4
5
6
7
8
9
10
11
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицы А и В
А = np array ([[1, 2, 3], [4, 5, 6]])
В = np . a rray ([ [7 , 8, 9], [10, 11, 12]])
# Вычитаем матрицы А и В
С = А - В
print("Результат вычитания матриц А и В ", С)
# Вывод:
# Результат вычитания матриц А и В: [[ -6 -6 -6]
» [-6 -6 -6]]
Тот же результат мы получим с помощью функции np. subtract О
При этом результат вычитания матриц .4 и В задастся с помощью кода
С = np.subtract(А, Б)
5.14.5. Умножение матриц
Для умножения матриц в NumPy используется оператор @ или функция
np.matmulO. Размеры матриц должны быть согласованы для умножения, то
есть количество столбцов первой матрицы должно быть равно количеству строк
второй матрицы.
Выполним умножение матрицы А размера 2x3 на число (скаляр) 3
с помощью оператора *.
Листинг 5.111: Пример умножения матрицы на число с помощью оператора *
—
1 # Импортируем библиотеку NumPy
з import numpy as np
з # Создаем матрицу A
4 A = np. array (([1 , 2, 3], [4, 5, 6]])
s # Умножаем матрицу А на число 3
в В = A * 3
т print("Результат умножения матрицы А на число 3:", В)
s # Вывод: Результат умножения матрицы А на число 3:
-> [[ 3 6 9]
э #
[12 15 18]]
Тот же результат мы получим с помощью функции np.multiply О При
этом результат умножения матрицы А на число 3 задается с помощью кода
В = np.multiply(A, 3).
Выполним матричное умножение матрицы Л размера 2 х 3 и матрицы 13
размера 3 х 2 с помощью оператора й
Листинг 5.112: Пример умножения матриц с помощью оператора Q
л
1 # Импортируем библиотеку NumPy
2 import numpy as np
з # Создаем матрицы А и В
4 А = np array ([[1, 2, 3], [4, 5, 6]])
s В = np array([[7, 8], [9, 10], [11, 12]])
в # Умножаем матрицы А и В
т С = А ® В
s print("Результат умножения матриц А и В:", С)
9
10
# Вывод: Результат умножения матриц А и В: [[ Ь8 64]
# [139 154]]
Тот же результат мы получим с помощью функции np.matmul().
При этом результат умножения матриц А и В задается с помощью кода
С = np.matmul(A, В).
Замечание 6. Оператор Ф и функция np.matmulO являются эквивалентными
и могут использоваться взаимозаменяемо для матричного умножения. Опера-
тор * используется для поэлементного умножения матриц, то есть для умноже-
ния соответствующих элементов матриц, а не для матричного умножения.
5.14.6. Определитель и след матрицы
Функция пр.linalg det О используется для вычисления определителя
квадратной матрицы. Она принимает па вход квадратную матрицу и возвра-
щает ее определитель.
Вычислим определитель матрицы А размера 2 х 2 с помощью функции
пр. linalg.detO
Листинг 5.113: Пример вычисления определителя матрицы
1
2
з
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as пр
it Создаем матрицу А
А = пр array ([[1, 2], [3, 4]])
# Вычисляем определитель матрицы А
det_A = пр linalg det(A)
print("Определитель матрицы A:", det_A)
# Вывод: Определитель матрицы А. -2.0
Если па вход функции пр. linalg. det О передана не квадратная матри-
ца. будет вызвано исключение LinAlgError.
Функция пр.trace() используется для вычисления следа матрицы.
Синтаксис функции’
Листинг 5.114: Синтаксис функции np.tracc()
1 np.trace(a, offset-0, axisl=O, axis2-l, dtype=None, <—»
—r out = None)
где
• а входная матрица;
• offset — смещение от главной диагонали (по умолчанию 0, то есть глав-
ная диагональ);
* axisl. axis2 оси для определения двумерных подмассивов (по умолча-
нию 0 и 1);
• dtype — тип данных для результата (по умолчанию None);
• out массив, в который будет записан результат (по умолчанию None).
Данная функция возвращает сумму элементов но диагоналям массива:
• Если массив а двумерный, возвращается сумма элементов по его диаго-
нали с заданным смещением (offset). Формально, это сумма элементов
a[i , i+offset] для всех допустимых индексов i
• Для массивов с более чем двумя измерениями, функция рассматрива-
ет массив как набор двумерных подмассивов, определенных осями axisl
и axis2. Для каждого такого подмассива вычисляется след по указанной
диагонали, и результаты объединяются в выходной массив. Форма резуль-
тирующего массива совпадает с формой исходного массива а. ио без осей
axislи axis2.
Вычислим след матрицы Л размера 2x2 с помощью функции
np.trace():
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу A
A = np array ([[1, 2], [3, 4]])
# Вычисляем след матрицы A
trace.A = np.trace(A)
print("След матрицы A:", trace_A)
v Вывод: След матрицы A. 5
Листинг 5.115: Пример вычисления следа матрицы с помощью функции
np .traced
1
2
3
«I
5
6
7
8
9
Замечание 7. След матрицы это сумма ее диагональных элементов. След
в линейной алгебре вычисляется только для квадратных матриц, но функция
np.traced не вызывает исключение, если матрица не квадратная. В этом слу-
чае функция просто суммирует элементы по диагоналям (с учетом смещения),
которые существуют в матрице.
5.14.7. Обратная матрица
Функция пр.linalg.invО используется для вычисления обратной мат-
рицы. Она принимает на вход квадратную матрицу и возвращает се обратную
матрицу, если она существует. Если матрица вырождена (нс имеет обратной
матрицы), будет вызвано исключение LinAlgError.
Вычислим обратную матрицу Л размера 2 х 2 с помощью функции
np linalg.invО.
Листинг 5.116: Пример вычисления обратной матрицы
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу A
A = np . array ([ Ll , 2], [3, 4]])
§5.15. Норма вектора и норма матрицы
6
7
8
9
10
11
# Вычисляем обратную матрицу А
inv_A = пр.linalg.inv(А)
print(“Обратная матрица А:“, inv.A)
# Вывод: Обратная матрица А:
# LE-2. 1. ]
# [ 1 5 -0.5]]
Замечание 8. Перед использованием функции пр. linalg. invО необходимо
убедиться, что матрица является квадратной и невырожденной (имеет нену-
левой определитель). Если матрица вырождена, то обратная матрица нс суще-
ствует. и будет вызвано исключение LinAlgError.
§5.15. Норма вектора и норма матрицы
Функция пр.linalg.normO используется для вычисления нормы векто-
ра или матрицы. Синтаксис функции:
Листинг 5.117: Синтаксис функции np.linalg.normO
1 пр. linalg.попе (а, ord = None , axis = None , keepdims=False)
где
• а — входной массив;
* ord порядок нормы (по умолчанию None, т. с. используется норма Фро-
бениуса для матриц и 2-норма для векторов):
• axis оси, по которым вычисляется норма (по умолчанию None, т. е.
вычисляется норма всего массива):
• keepdims — если True, сохраняются размерности входного массива (но
умолчанию False).
Вычислим норму вектора а с помощью функции np linalg.nonrO:
# Импортируем библиотеку NamPy
import numpy as np
# Создаем вектор
a = np array(f3, 4])
# Вычисляем норму вектора а
norm_a = np.linalg norm(а)
print("Норма вектора a:", norm_a)
# Вывод: Норма вектора а: 5.0
Листинг 5.118: Пример вычисления нормы вектора
i
2
3
5
6
7
8
9
Вычислим норму матрицы .4 с помощью функции np.linalg.norm():
Листинг 5.119: Пример вычисления нормы матрицы
1
2
3
4
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу
A = np.array([Ll , 2], [3, 4J])
# Вычисляем норму матрицы A
norm_A = np.linalg norm(A)
print("Норма матрицы A ", norm_A)
# Вывод: Норма матрицы A: 5.477225575051661
Замечание 9. Норма вектора — это мера его длины, а норма матрицы — это
мера се размера. В NumPy по умолчанию используется 2-норма для векторов
и норма Фробениуса для матриц, но можно указать другой порядок нормы
с помощью параметра ord
§5.16. Ранг матрицы
Функция np. linalg ,matrix_rank() может быть использована для опре-
деления ранга матрицы, что является важным шагом в процессе приведения
матрицы к ступенчатому виду.
Синтаксис функции:
Листинг 5.120: Синтаксис функции np.linalg.matrix_rank()
1 np.linalg matrix_ranx(а, tcl = None)
где
• а — входная матрица;
* tol — пороговое значение для определения нулевых сингулярных значе-
ний (по умолчанию None, т. е. используется значение по умолчанию, зави-
сящее oi размера матрицы).
Вычислим ранг матрицы Я с помощью функции
np.linalg.matrix_rank().
Листинг 5.121: Пример вычисления ранга матрицы
i
2
3
4
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу A
A = np.array([[1, 2], [3, 4]])
# Вычисляем ранг матрицы A
rank_A = np.linalg.matrix.rank(A)
print("Ранг матрицы A;", rank_A)
# Вывод: Ранг матрицы A: 2
§5.17. Решение систем линейных уравнений
Функция пр linalg.solveO используется для решения систем линей-
ных уравнений вида Ах = Ь, где Л — матрица коэффициентов, х — вектор
неизвестных, b вектор свободных членов. Данная функция предназначена
для решения квадратных систем линейных уравнений, где количество уравне-
ний равно количеству неизвестных. Если матрица коэффициентов А не явля-
ется квадратной или вырождена (по имеет обратной матрицы), будет вызвано
исключение LinAlgError.
Синтаксис функции пр. linalg. solve О :
Листинг 5.122: Синтаксис функции пр. linalg. solve О
1
пр.1зпаlg.so 1ve(а, b)
где
• а — матрица коэффициентов:
• b — вектор свободных членов.
Решим систему линейных уравнений с помощью функции
пр.linalg.solve О.
Листинг 5.123: Пример решения системы линейных уравнений с помощью функ-
ции пр linalg.solve()
1
2
3
4
5
6
7
8
9
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем матрицу коэффициентов
А = пр.array([[3, 2], [1, 2]])
# Создаем вектор свободных членов
В = пр.array([5, 3])
# Решаем систему линейных уравнений
X = пр.linalg.solve(А , В)
§5.17. Решение систем линейных уравнений
10
и
print("Решение системы линейных уравнений:", X)
# Вывод: Решение системы линейных уравнений: [1. 1.]
Замечание 10. Самостоятельно можно реализовать метод обратной матрицы
и метод Крамера для решения системы линейных уравнений.
Также можно использовать функцию np.linalg.IstsqO для решения
переопределенных спетом линейных уравнений, где количество уравнений боль-
ше, чем количество неизвестных. Данная функция находит наилучшее прибли-
жение решения в смысле наименьших квадратов. Синтаксис функции.
Листинг 5.124: Синтаксис функции пр. linalg. IstsqO
np.1inalg.Istsq (а , b, rcond = None)
где
* а матрица коэффициентов;
• b вектор свободных членов;
• rcond пороговое значение для определения нулевых сингулярных зна-
чений (по умолчанию None, т. е. используется значение по умолчанию, за-
висящее от размера матрицы).
Решим переопределенную систему линейных уравнений с помощью
функции np. 1 inalg. 1 stsq ().
Листинг 5.125: Пример решения переопределенной системы линейных уравне-
ний с помощью функции np.linalg. IstsqO
1
2
3
4
5
б
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу коэффициентов
А = np.array([[1, 2], [3» 4], [5, 6]])
# Создаем вектор свободных членов
7
8
9
1ч
11
В = np array([7, 8, 9])
# Ре_аем переопределенную систему линейных уравнений
X, residuals, rank, s = np . linalg.Istsq(А , В,
rcond=Kone)
print("Решение переопределенной системы линейных ypa<—>
внений:" , X)
# Вывод: Решение переопределенной системы линейных у<—’
i~> равнений: [1. 1.]
В данном примере функция np. linalg. IstsqO возвращает решение си-
стемы линейных уравнений, а также дополнительные параметры:
• residuals остатки (разность между вектором свободных членов и про-
изведением матрицы коэффициентов на решение);
• rank ранг матрицы коэффициентов:
• s сингулярные значения матрицы коэффициентов;
• X решение системы линейных уравнений.
§5.18. Сингулярное разложение матрицы
Функция np.linalg.svdО используется для вычисления сингулярного
разложения матрицы. Синтаксис функции:
Листинг 5.126: Синтаксис функции np.linalg.svdО
1 пр.linalg.svd(а , full.matrices=True , <—>
> compute_uv = True, hermitian = False)
где
• а входная матрица;
• full.matrices — если True, возвращаются полные матрицы U и V1 (но
умолчанию True);
• compute_uv — если True, возвращаются матрицы U и V г (по умолчанию
True);
• hermitian — если True, входная матрица считается эрмитовой (по умол-
чанию False).
Сингулярное разложение матрицы /1 размера т х п представляет се
в виде произведения трех матриц: Л = USV1, где U — ортогональная мат-
рица размером т х т. S — диагональная матрица размером т х п с неот-
рицательными элементами (сингулярными значениями) на диагонали, а V1
транспонированная ортогональная матрица размером п х п.
Найдем сингулярное разложение .матрицы .4 с помощью функции
np.linalg.svd().
Листинг 5.127: Пример сингулярного разложения матрицы с помощью функции
пр linalg.svdО
1
2
3
4
5
е
7
8
9
10
11
12
13
14
15
16
17
# Импортируем библиотеку NumPy
import numpy as пр
# Создаем матрицу
А = пр array ([[1, 2], [3, 4], [5, 6]])
# Вычисляем сингулярное разложение
U, S, VT = пр.linalg.svd(А)
print("Матрица U", U)
print("Сингулярные значения:", 3)
print("Матрица V“T;", VT)
# иывод:
# Матрица U: [[-0.3863177 -0.9'223658 1
# [-0.9223658 0.3863177 ]
it [-0.17149859 0 ]
# Сингулярные значения: [9 508032 0.77286964]
# Матрица V*T: [[-0.42866713 -0.56630692]
# [-0.80596391 0.11238241]]
Замечание 11. Сингулярное разложение матрицы является мощным инстру-
ментом в линейной алгебре и используется для решения различных задач, та-
ких как сжатие данных, понижение размерности, решение переопределенных
систем линейных уравнений и др. Сингулярные значения матрицы S упорядо-
чены по убыванию, и их количество равно минимальному размеру матрицы Л.
Если матрица Л является квадратной, то U и Г1 * будут квадратными матри-
цами размером т х т и п х п соответственно. Если матрица Л не является
квадратной, то U будет размером т х т. S будет размером т х n. a V1 будет
размером п х п.
§5.19. QR-разложение матрицы
Функция np.linalg qr() используется для вычисления QR-разложсиия
матрицы, которое представляет матрицу в виде произведения ортогональной
матрицы Q и верхней треугольной матрицы /?. Синтаксис функции:
Листинг 5.128: Синтаксис функции np.linalg.qr()
i пр.linalg qr(а, mode = ’гeduced ’ )
где
• а входная матрица:
• mode режим разложения (’reduced’ сокращенное QR-разложение,
’complete’ полное QR-разложение, ’г’ — только матрица R).
Найдем QR-разложение матрицы с помощью функции np.linalg qrО.
Листинг 5.129: Пример (JR-разложения матрицы с помощью функции
np.linalg.qr()
1
2
3
4
# Импортируем библиотеку NumPy
import numpy as np
# Создаем матрицу
5
6
7
8
9
10
11
12
13
11
А = np array([[1, 2], [3, 4]])
# Вычисляем QR-разложение
Q, R = np.linalg qr(A)
print("Матрица Q:“, Q)
print("Матрица R:", R)
# Вывод:
# Матрица Q; [[-0 31622777 -0.9486833 ]
# [-0.9486833 0.31622777]]
# Матрица R: [[-3.16227766 -4.42718872]
U [ 0. 0.63245863]]
Замечание 12. QR-разложение матрицы используется для решения систем ли-
нейных уравнений, вычисления собственных значений и векторов, а также для
других задач линейной алгебры. Матрица Q является ортогональной, то есть
QTQ = /, где I единичная матрица. Матрица В является верхней треугольной
матрицей. Если матрица А является квадратной, то Q будет размером т х т,
а В будет размером т х п. Если матрица Л не является квадратной, то Q будет
размером тх т, а В будет размером тхп, где т — количество строк в матрице
Лап - количество столбцов в матрице А.
§ 5.20. Разложение Холецкого
Функция np.linalg.choleskyO используется для вычисления разложе-
ния Холецкого матрицы А, которое представляет положительно определенную
матрицу в виде произведения нижней треугольной матрицы L и транспониро-
ванной к пей матрицы L'.
Найдем разложение Холецкого матрицы А с помощью функции
np. linalg. choleskyO:
Листинг 5.130: Пример разложения Холецкого
1
2
3
4
# Импортируем библиотеку NumPy
import numpy as np
# Создаем положительно определенную матрицу
5
6
7
8
9
10
11
12
13
14
А = пр array ([Г4, 2] , Г 2, 3] ] >
# Вычисляем разложение Хилецкого
L = пр linalg.cholesky(А)
print ( "Матрица L : 11 , L)
# Проверка равенства L 3 L.T == А
print ("Равенство L © L.T == А верно
пр, allclose (L О L.T, А))
# Вывод:
# Матрица L: [[2. 0.]
# [1. l.]J
# Равенство L Q L.T -= А верно: True
Замечание 13. Разложение Холсцкого используется для решения систем линей-
ных уравнений, вычисления определителя и других задач линейной алгебры.
Матрица А должна быть положительно определенной, иначе будет вызвано ис-
ключение LinAlgError. Если матрица А является положительно определенной,
то матрица L будет нижней треугольной матрицей, а £7 будет верхней тре-
угольной матрицей.
§5.21. Собственные значения и собственные векторы
Для вычисления вещественных собственных значений и собствен-
ных векторов матрицы в NuniPy используются функции пр. linalg. eigO
и пр. linalg. eigvalsO. Собственные значения и векторы матрицы А — это
такие числа А и векторы v, что выполняется равенство А?» = Xv. Собственные
значения А — это скаляры, а собственные векторы г’ — это ненулевые векторы,
соответствующие этим собственным значениям.
Вычислим собственные значения и собственные векторы с помощью
функции np.linalg.eigO:
Листинг 5.131: Пример вычисления собственных значений и векторов с помо-
щью функции пр,linalg eig()
—
i # Импортируем библиотеку NumPy
2 import numpy as пр
3
4
5
6
7
8
9
10
11
12
13
14
# Создаем квадратную матрицу
А = пр аггау([[4, -2] , [1, 1]])
# вычисляем собственные значения и векторы
eigenvalues, eigenvectors = пр.linalg.eig(А)
print("Собственные значения:", eigenvalues)
prInt("Собственные векторы:", eigenvectors)
К вывод:
# Собственные значения: [3. 2.]
# Собственные векторы:
# [[ 0.89442719 -0.70710678]
# [ 0.4472136 0.70710678]]
Функция np.lina.lg.eigO возвращает два значения:
• eigenvalues массив собственных значений;
• eigenvectors матрица, столбцы которой являются собственными век-
торами.
Функция пр. linalg. eigvals () используется для вычисления только
собственных значений матрицы, без собственных векторов.
Контрольные вопросы
1. Что такое библиотека NumPy?
2. Для чего предназначена библиотека NuniPy?
3. Как импортировать библиотеку NumPy в Python?
4. Какое стандартное сокращение используется для NuniPy?
5. В чем основные преимущества NuinPy перед стандартными списками
Python?
6. Что такое ndarray в контексте NuniPy?
7. Какие типы данных поддерживает NumPy?
8. Как установить библиотеку NumPy?
9. Как создать одномерный массив из списка Python?
10. Что делает функция пр.аггау()?
11. Как создать многомерный массив?
12. Что такое функция np.zcros() и как она используется?
13. Для чего предназначена функция np.ones()?
14. Что делает функция np.empty()?
15. Как создать массив с единичной матрицей?
16. Что такое функция np.arangeQ и чем она отличается от range()?
17. Как создать массив с равномерно распределенными значениями?
18. Что делает функция np.linspace()?
19. Как создать случайный массив?
20. 13 чем разница между np.zeros() и np.emptyQ?
21. Что показывает атрибут shape массива?
22. Что такое размерность массива (ndim)?
23. Как узнать общее количество элементов в массиве?
24. Что показывает атрибут dtype?
25. Как узнать размер одного элемента в байтах?
26. Как получить элемент одномерного массива по индексу?
27. Как работает отрицательная индексация в NumPy?
28. Как получить элемент многомерного массива?
29. Что такое срезы (slicing) в NumPy?
30. Как получить подмассив с помощью срезов?
31. Что означает запись массив[::2|?
32. Как изменить несколько элементов массива одновременно?
33. Что такое булева индексация?
34. Как использовать массив индексов для выборки элементов?
35. В чем разница между копией и представлением массива?
36. Что делает метод reshapeQ?
37. Можно ли изменить форму массива с сохранением общего количества эле-
ментов?
38. Что означает параметр -1 в функции rcshape()?
39. Как преобразовать многомерный массив в одномерный?
40. Что делает функция np.transpose()?
41. Как поменя ть местами оси массива?
42. Что такое функция np.ravcl()?
13. В чем разница между flatten() и ravc)()?
44. Как добавить новую ось к массиву?
45. Что делает функция np.squeeze()?
16. Как выполнить операцию между массивом и скаляром?
47. Что происходит при сложении массивов разных размеров?
48. Что такое broadcasting в NuniPy?
49. Какие правила действуют при broadcasting?
50. Как выполнить матричное умножение массивов?
51. В чем разница между операторами * и 0 для массивов?
52. 11то делают функции np.add(), np.subtract(), np.inultiply()?
53. Как вычислить степень элементов массива?
54. Что такое универсальные функции (ufunc) в NumPy?
55. Какие преимущества дают ufunc?
5(5 . Приведите примеры математических ufunc.
57. Что делают функции np.sin(), np.cosQ, пр.ехр()?
58. Как найти максимальное и минимальное значения в массиве?
59. Что такое функции-агрегаторы?
60. Как вычислить сумму всех элементов массива?
61. Что делает функция пр.тсап()?
62. Как найти индекс максимального элемента?
63. Что такое функция np.where()?
64. Как вычислить среднее арифметическое массива?
65. Что делает функция np.median()?
66. Как найти стандартное отклонение?
67. Что вычисляет функция np.var()?
68. Как найти процентили массива?
69. Как вычислить корреляцию между массивами?
70. Что делает функция np.cov()?
71. Как найти уникальные элементы массива?
72. Что возвращает функция np.bincount()?
73. Что такое NaN в NumPy?
74. Как создать массив с NaN значениями?
75. Что делает функция np.isnan()?
76. Как проверить наличие бесконечных значений?
77. Что такое функции nanmean(), nansum(), nanstd()?
78. Как удалить NaN значения из массива?
79. Что делает функция np.nan _to_ num()?
80. Как заменить NaN значения на друг не числа?
81. Как отсортировать массив ио возрастанию?
82. Что возвращает функция np.argsort()?
83. Как выполнить сортировку многомерного массива по определенной оси?
84. Что делает функция np.sort()?
85. В чем разница между np.sortQ и методом .sortO?
86. Как найти к наименьших элементов массива?
87. Что такое функция np.searchsortedO?
88. Как найти индексы элементов, удовлетворяющих условию?
89. Как объединить два массива по горизонтали?
99. Что делает функция np.concatenate()?
91. В чем разница между np.hstackQ и np.vstackO?
92. Как разделить массив на несколько частей?
93. Что такое функция np.split()?
94. Как добавить элементы в масс ив?
95. Что делает функция np.appcnd()?
96. Как удалить элементы из массива?
97. Как вставить элементы в определенную позицию массива?
98. В чем разница между поверхностной и глубокой копией?
99. Что делает метод .сору()?
100. Когда следует создавать копию массива?
101. Как решить систему линейных уравнений с помощью NumPy?
102. Что такое модуль пр.linalg?
103. Как вычислить собственные значения матрицы?
104. Что делает функция np.dot()?
105. Как выполнить разложение матрицы?
106. Как генерировать случайные числа с помощью NumPy?
107. Что предоставляет модуль np.random?
108. Как создать выборку из различных распределений?
109. Почему NumPy массивы быстрее списков Python?
НО. Что такое векторизация в контексте NumPy?
111. Как избежать циклов при работе с массивами?
112. Как задать вектор-строку и вектор-столбец в NuniPy?
113. Как создать матрицу с нулями и единицами в NuniPy?
111. Как создать единичную матрицу в NumPy?
115. Как создать матрицу с произвольными значениями в NumPy?
116. Как найти произведение матриц с помощью NuniPy?
117. Как найти 'транспонированную матрицу с помощью NuniPy?
118. Как найти след матрицы с помощью NumPy?
119. Как найти определитель матрицы с помощью NumPy?
120. Как найти собственные значения и собственные векторы матрицы?
121. Как найти обратную матрицу с помощью NumPy?
122. Как вычислить норму векторов и матриц в NumPy?
123. Как найти ранг матрицы с помощью NumPy?
124. Как решить систему линейных уравнений с помощью NuinPy?
125. Как выполнить сингулярное разложение матрицы в NumPy?
126. Как выполнить QR-разложенне матрицы в NumPy?
127. Как выполнить разложение Холсцкого матрицы в NuinPy?
Практикум: работа с массивами NumPy
1. Создайте одномерный массив из целых чисел от 0 до 9 включительно.
Выведите массив и его форму.
2. Создайте одномерный массив из пяти нулей. Убедитесь, что это массив
типа float64. Выводите тип и массив.
3. Создайте массив размером 3x4, заполненный единицами. Выведите мас-
сив и его размерность (ndim) и форму (shape).
4. Создайте массив размером 2 х 3, в котором все элементы равны 7. Исполь-
зуйте функцию пр.full
5. Создайте массив размером 3 х 2, заполненный случайными числами от
1 до 100. Выводите массив и его размерность (ndim) и форму (shape).
Используйте пр.random, randint.
6. Создайте массив из 5 чисел, равномерно распределенных па отрезке от 0
до 1. Используй re пр linspace
7. Создайте одномерный массив из 10 случайных чисел с плавающей точкой
от 0 до 1. Используйте np.random.rand.
8. Создайте одномерный массив из 10 чисел и измените его форму на мат-
рицу размером 2x5. Выведите новую форму.
9. Создайте одномерный массив и преобразуйте его в вектор-столбец (форма
3 х 1) и в вектор-строку (форма 1 х 3). Объясните разницу.
10. Создайте массив с нулями размером 3x3.
И. Создайте, массив с единицами размером 4x4.
12. Создайте одномерный массив со значениями от 10 до 50 с шагом 5. Ис-
пользуйте np.arange.
13. Создайте массив с равномерно распределенными числами от 1 до 10
с шагом 0.5.
14. Создайте случайный массив размером 2 х 3 с числами от 0 до 1.
15. Создайте массив из целых чисел и преобразуйте его в тип float. Проверь-
те и выведите новый тип данных массива.
16. Создайте массив из 10 случайных чисел с плавающей точкой от 10 до 100.
Получите третий элемент этого массива. Выведите его на экран.
17. Создайте массив из 5 чисел. Замените все элементы массива, кроме по-
следнего, па 0. Последний элемент должен быть равен 99.
18. Создайте двумерный массив. Найдите максимальное и минимальное зна-
чение в этом массиве.
19. Создайте двумерный массив. Найдите максимальное значение в каждом
столбце и минимальное значение в каждой строке.
20. Создайте двумерный массив и найдите сумму и произведение всех его
элементов.
21. Создайте двумерный массив и найдите среднее значение но каждому
столбцу и строке.
22. Создайте двумерный массив и найдите максимальное значение по диаго-
нали.
23. Создайте массив и скопируйте его двумя способами: с использованием опе-
ратора = и функции сору (). Измените копию и сравните, как это повлияло
на оригинал.
24. Создайте двумерный массив и транспонируйте его.
25. Создайте одномерный массив из 10 чисел и получите срез первые 5
элементов. Выведите срез.
26. Создайте двумерный массив и получите срез — первые 2 строки и 3 столб-
ца.
27. Создайте двумерный массив и получите срез все строки, кроме послед-
ней, и все столбцы, кроме первого.
28. Создайте двумерный массив и получите срез все строки и столбцы, где
значения больше 5.
29. Создайте двумерный массив и получите срез — все строки, где значения
в первом столбце больше 2, и все столбцы, кроме последнего.
3U. Создайте двумерный массив и получите срез все строки, где значения
в первом столбце меньше 3.
31. Создайте одномерный массив из 20 случайных чисел от 50 до 200 и про-
верьте, содержит ли массив хотя бы одно значение больше 100. Исполь-
зуйте логическую маску и np.any.
32. Создайте двумерный массив и получите булеву маску, где значения боль-
ше 5. Выведите маску.
33. Создайте двумерный массив и получите индексы элементов, которые боль-
ше 5. Используйте np. where.
34. Создайте двумерный массив и получите индексы элементов, которые
меньше 3. Используйте np where
35. Создайте массив с повторяющимися значениями и найдите уникальные
значения. Используйте пр.unique.
36. Создайте массив и проверьте, все ли его элементы положительные. Ис-
пользуйте пр.all
37. Создайте массив и проверьте, есть ли в нем хотя бы одно значение меньше
пуля. Используйте пр. any.
38. Создайте массив из 10 случайных чисел и отсортируйте его по возраста-
нию. Используйте пр . sort.
39. Создайте массив из 10 случайных чисел и отсортируйте его но убыванию.
Используйте пр.sort с параметром axis=-l.
40. Создайте двумерный массив и отсортируйте его по первому столбцу. Ис-
пользуйте пр.argsort для получения индексов сортировки.
41. Создайте двумерный массив и отсортируйте его по второму столбцу. Ис-
пользуйте пр.argsort для получения индексов сортировки.
42. Создайте два двумерных массива и объедините их по горизонтали. Ис-
пользуйте np.hstack.
43. Создайте два двумерных массива и объедините их по вертикали. Исполь-
зуйте np.vstack.
44. Создайте двумерный массив и разделите его на 3 части по горизонтали.
Используйте пр. spl11.
45. Создайте двумерный массив и разделите его на 2 части по вертикали.
Используйте пр.split.
46. Создайте массив с числами от 1 до 12 и измените его форму па 3 х 4.
Используйте пр. reshape.
47. Создайте массив с числами от 1 до 9 и добавьте новую ось. Используйте
np.newaxis или np.expand_dims
48. Создайте двумерный массив, содержащий числа, пр.пап и пр.inf. Заме-
ните все пр.пап на 0 и все пр inf на 1. Используйте пр .nan_to_nuni
49. Создайте двумерный массив, содержащий числа и пр.пап значения. Най-
дите сумму всех элементов, игнорируя пр.пап. Используйте np.nansum.
50. Создайте двумерный массив, содержащий числа и пр.пап значения. Най-
дите среднее значение всех элементов, игнорируя пр.пап Используйте
пр .папшеап.
51. Создайте двумерный массив, содержащий числа и пр.пап значения. Заме-
ните все пр.пап значения па среднее значение других элементов. Исполь-
зуйте пр.пашпеап для вычисления среднего.
52. Создайте двумерный массив, содержащий числа и пр.пап значения. Уда-
лите все строки, содержащие хотя бы одно пр пап значение. Используйте
пр. isnan и логическую индексацию.
53. Создайте два вектора но 5 элементов и выполните поэлементное сложение,
вычитание. Выведите результат.
54. Создайте два вектора по 5 элементов и выполните поэлементное умноже-
ние и матричное умножение. Сравните результаты.
55. Создайте два вектора по 5 элементов и выполните поэлементное возведе-
ние в степень. Выведите результат.
56. Создайте матрицу 2 х 3 и умножьте се на скаляр 10. Выведите результат.
57. Создайте матрицу 2 х 3 и возведите каждый элемент в квадрат.
53. Создайте два двумерных массива и выполните матричное умножение. Вы-
ведите результат.
59. Создайте двумерный массив, заполненный натуральными числами от 1 до
12. Замените все четные числа в массиве на —1. Используйте логическую
маску.
60. Создайте двумерный массив, заполненный натуральными числами от 1 до
12. Извлеките из него все нечетные числа.
61. Создайте двумерный массив, заполненный натуральными числами от 1 до
12. Замените все числа, большие 6, на 0. Используйте логическую маску.
62. Создайте квадратную матрицу и вычислите ее детерминант.
63. Создайте квадратную матрицу и вычислите ее обратную матрицу.
64. Создайте квадратную матрицу и найдите се след.
65. Создайте квадратную матрицу и найдите ее норму.
66. Создайте квадратную матрицу и найдите се ранг.
67. Создайте квадратную матрицу и найдите ее собственные значения и соб-
ственные векторы.
68. Решите систему линейных уравнений Ах = b с помошыо функции
np. linalg. so Ive () Для этого создайте квадратную матрицу А порядка
2 и подходящий век тор-столбец Ь.
69. Найдите общее решение системы линейных уравнений A.r = b с помощью
функции np.linalg.IstsqO. Для этого создайте квадратную матрицу А
порядка 3 и подходящий вектор-столбец Ь.
70. Решите систему линейных уравнений А.т = b с помощью метода обратной
матрицы. Для этого создайте квадратную матриц}7 А порядка 2 и подхо-
дящий вектор-столбец Ъ.
71. Решите систему линейных уравнений Ат = b с помощью метода Гаус-
са. Для этого создайте квадратную матрицу А порядка 3 и подходящий
вектор-столбец Ь.
72. Решите систему линейных уравнений Ат = b с помощью метода Краме-
ра. Для этого создайте квадратную матрицу А порядка 2 и подходящий
век юр-столбец Ь.
73. Решите систему линейных уравнений Ах = b с помощью метода Жорда-
на. Для этого создайте квадратную матрицу А порядка 3 и подходящий
вектор-столбец Ь.
Заключение
Заключение
В данной главе мы рассмотрели основные возможности библиотеки
NuinPy и научились работать с массивами, что является важным шагом
в освоении научных вычислений на Python. Библиотека NuinPy является осно-
вой для научных вычислений в Python и предоставляет мощные инструменты
для работы с многомерными массивами и матрицами. Ее возможности включа-
ют создание, изменение, индексацию и агрегацию массивов, а также выполнение
линейной алгебры и статистических операций. NuinPy позволяет эффективно
обрабатывать большие объемы данных и является неотъемлемой частью экоси-
стемы Python для научных вычислений. Благодаря своей производительности
и удобству использования. NuinPy широко применяется в различных областях,
включая машинное обучение, обработку изображений, численное моделирова-
ние и анализ данных.
Глава 6. Основы работы с библиотекой pandas
Данная глава посвящена описанию основных возможностей и функ-
циональности библиотеки pandas современного инструментария по анализу
и обработки данных в Python.
Библиотека pandas (от англ panel data, панельные данные) в настоящее
время является стандартом в анализе табличных данных на языке Python. Офи-
циальная документация для детального изучения функциональности pandas
приведена по ссылке https ://pandas pydata.org/. Следите за изменениями,
которые постоянно в нее вносятся. Актуальной на момент издания пособия вер-
сией библиотеки pandas является 2.20
§6.1 . Основы Series и DataFrame
Библиотека pandas является надстройкой над библиотекой NuinPy. Опа
предоставляет более простые и удобные инструменты для обработки данных.
Библиотека pandas более высокоуровневая, поэтому работа с пей более простая
и напоминает возможности табличного процессора MS Excel. Если основной
категорией NuinPy является многомерный массив, то в случае pandas это более
привычная и понятная таблица. Библиотека pandas используется для обработки
и анализа табличных данных. Ес ключевые структуры данных:
• Series одномерный массив, который может хранить данные различных
типов, аналогичный столбцу в таблице. Каждое значение сопровождается
индексом, который может быть как числовым, так и строковым.
* DataFrame это двумерная структура данных, подобная таблице MS
Excel или SQL Опа содержит строки и столбцы, каждый из которых пред-
ставляет собой объект Series
Структура данных Series библиотеки pandas сочетает в себе черты спис-
ков и словарей. Как и в списках, элементы Series можно выбирать по их ин-
дексу (позиции), которая начинается с нуля. Одновременно, как и в словарях,
к элементам можно обращаться ио ключам (меткам). Такая двойственная при-
рода делает Series очень гибким инструментом для работы с одномерными
данными, позволяя использовать и позиционную, и меточную индексацию.
Листинг 6.1: Пример создания объекта Series
1
2
3
4
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Подключаем библиотеку pandas
impcrt pandas as pd
# Создадим объект Series с пользовательскими метками*—*
«-> индекса
data = [100, 200, 300, 400]
labels = [’а’, ’b’, ’с’, ’d’]
s = pd.Series(data, index=labels)
# Выведем объект Series на экран
print(s)
# Вывод:
it a 100
# b 200
# c 300
# d 400
# dtype: int64
# Доступ к элементам Series по позициям (как в списке^
*-> е)
print(s[2]) # Вые од 300
# Доступ к элементам Series по меткам (как в словаре)
print(s [ ’ b’]) # Вывод: 200
В данном примере мы создали объект Series с пользовательскими мет-
ками индекса. Мы можем обращаться к элементам как но позициям (индексам),
так и но меткам (ключам). Если метки нс указаны, то по умолчанию использу-
ется числовой индекс, начинающийся с пуля. Объект Series может быть создан
из различных источников данных, таких как списки, массивы NumPy, словари
и другие структуры данных. При этом, значения в Series могут быть любо-
го типа, включая числа, строки и даже другие объекты. При печати объекта
Series на экран в левом столбце отображаются индексы, а в правом — соот-
ветствующие им значения. Также вы можете заметить, что в конце выводится
тип данных dtype. который в данном случае равен int64. что означает, что все
значения в Series являются целыми числами. Если в Series будут значения
разных типов, то dtype будет иметь значение object (это наиболее общий тип
данных в Python).
Создадим объект Senes из словаря.
Листинг 6.2: Пример создания объекта Series из словаря
1
2
3
4
Ь
6
7
8
9
1ч
11
12
13
# Подключаем библиотеку pandas
import pandas as pd
# Создадим объект Series из словаря
data = {’Anna’: 25, ’Bob’: 30, ’Charlie’: 35,
•-> David ’ : 40}
ages = pd.Series(data)
H Выведем объект Series на экран
print(ages)
# Вывод:
Anna 25
n Bob 30
Charlie 35
David 40
dtype: int64
В данном примере мы создали объект Series из словаря, то ключи слова-
ря будут использоваться в качестве индексов, а значения в качестве данных.
Если при создании объекта Senes in словаря мы укажем список индек-
сов, который будет иметь элемент, для которого нет значения в списке данных,
то недостающие элементы будут заполнены значением NaN (Not a Number), что
обозначает пропущенные значения.
Листинг 6.3: Пример создания объекта Scries с пропущенными значениями
-----------------------------------------------------------X
1 # Подключаем библиотеку pandas
2 import pandas as pd
з # Создадим объект Series с пропущенными значениями
4 age = {’Anna’ 25, ’Boris’: 33, ’Ivan’: 57, ’Chen’: <—
‘ 45, ’Alice ’ : 17}
5 names = [’Helen’, ’Boris’, ’Ivan’, ’Chen’, ’Alice’]
e ages = pd Series(age, index = names)
7 ages
8 # Вывод:
9 # Helen NaN
10 # Boris 33.0
11 # Ivan 57.0
12 # Chen 45.0
13 # Alice 17.0
14 # dtype : float64
Объект Series имеет множество полезных атрибутов, которые облегча-
ют работу с данными. В таблице 6.1 приведены основные атрибуты объекта
Senes.
Таблица 6.1: Основные атрибуты объекта Series библиотеки pandas
Атрибут Описание
values Возвращает массив NuinPy, содержащий дан- ные Series
index Возвращает индекс (метки строк) Series.
dtype Возвращает тин данных элементов Series
dtypes Возвращает типы данных каждого элемента Series.
shape Возвращает форму (размер) Series в виде кор- тежа.
size Возвращает количество элементов в Senes.
ndim Возвращает количество измерений Series (все- гда 1 для Series).
name Возвращает имя Senes
hasnans Возвращает True, если в Senes есть пропущен- ные значения.
T Возвращает транспонированный объект Series.
empty Возвращает True, если Series пустая.
Для работы с объектом Senes предусмотрено множество методов, кото-
рые позволяют выполнять различные операции над данными, такие как филь-
трация, агрегация, преобразование и другие. В таблице 6.2 приведены основные
методы объекта Series
Таблица 6.2: Основные методы объекта Series библиотеки pandas
Метод Описание
head(n) Возвращает первые n элементов Series.
tail(n) Возвращает последние п элементов Series
describe() Возвращает описание статистик Series.
mean() Возвращает среднее значение элементов Series.
suxiiO Возвращает сумму элементов Series
min() Возвращает минимальное значение элементов Series
max() Возвращает максимальное значение элемен- тов Series
std() Возвращает стандартное отклонение элемен- тов Series
varO Возвращает дисперсию элементов Series
count() Возвращает количество ненулевых элементов Series.
uniqueO Возвращает уникальные значения элементов Series.
nuniqueO Возвращает количество уникальных значений в Series.
value_counts() Возвращает количество уникальных значений в Series.
apply(func) Применяет функцию June ко всем элементам Series.
map(fnnc) Применяет функцию func ко всем элементам Series и возвращает новый Series.
dropnaO Удаляет пропущенные значения из Series.
filIna(value) Заменяет пропущенные значения в Series па указанное значение value
Метод Описание
astype(type) Преобразует тип данных элементов Series в указанный тип type.
sort.values(ascending=True) Сортирует значения в Series по возрас- танию (ascending=Truej или убыванию (ascending^False).
sort.index(ascending=True) Сортирует индексы в Series по возрас- танию (ascending-True) или убыванию (ascending-False).
reset.index(drop-False) Сбрасывает индексы Series и возвраща- ет новый Series с новым индексом. Если drop=True. старый индекс не сохраняется.
rename(index=mapper) Переименовывает метки индекса в Series со- гласно словарю mapper
reindex(index) Изменяет индексы Series согласно новому индексу index.
isnullO Возвращает булеву серию, указывающую па пропущенные значения.
notnullO Возвращает булеву серию, указывающую на ненулевые значения.
idxmaxO Возвращает индекс первого вхождения мак- симального значения.
idxminO Возвращает индекс первого вхождения мини- мального значения.
Для применения (вызова) методов и атрибутов объекта Series можно
использовать точечную нотацию.
Листинг 6.4: Пример применения методов и атрибутов объекта Series
1
2
3
4
5
6
# Подключаем библиотеку pandas
import pandas as pd
# Создадим объект Series
s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
index^listC’abcdefghij*))
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Применяем атрибуты
print(s.values) # Вывод: массив значений Series
# Вывод: [123456789 10]
print (s. index) # Вывод [a, b, с, d, е, f, g,
h, i, j]
к Применяем методы
pr int (s . head (2) ) # Вывод, первые 2 элемент?.
# Вывод:
# а 1
# b 2
print(s.tail (3)) # Вывод: последние 3 элемента
# Зывод:
И h 8
it i 9
# j 10
Структура данных DataFrame является основным объектом библиотеки
pandas для работы с табличными данными. Он представляет собой двумерную
структуру данных, состоящую из строк и столбцов, напоминающую электрон-
ную таблицу MS Excel, по с гораздо более широкими возможностями. Каждый
столбец в DataFrame является объектом Senes, что позволяет использовать
все методы и атрибуты, доступные для Senes Pandas предлагает множество
удобных методов для работы с такими таблицами: от SQL подобных операций
до гибкой загрузки и сохранения в разных форматах файлов, например файлы
csv, xlsx, SQL и другие. В отличие от NumPy, где весь массив должен быть
одного типа, в DataFrame каждый столбец может хранить данные собственно-
го типа — целые числа, дробные числа, даты, строки и другие. Кроме того,
pandas легко интегрируется с базами данных и умеет обрабатывать данные из
множества источников, что делает ее незаменимым инструментом при анализе
и предобработке табличных данных.
Существует множество способов создать объект DataFrame, но одни из
наиболее распространенных — передать в конструктор словарь, где ключи
это названия столбцов, а значения — списки или массивы одинаковой длины.
Создадим объект DataFrame (или датафрейм) из словаря, где ключи бу-
дут метками столбцов, а значения списками значений для каждого столбца.
Листинг 6.5: Пример создания объекта DataFrame
1 # Подключаем библиотеку pandas
2 import pandas as pd
3
4 # Создаем словарь с данными
5 data = {
6 ’Нате’: Г ’ Anna ’ , ’Boris’, ’Ivan’, ’Chen’, ’ e-5
7 <—> Alice ’ ] , ’City’: [’Moscow’, ’Minsk’, ’New York’, ’+-»
8 Shanghai’, ’London’], ’Age’: [25, 33, 57, 45, 17]
9 >
10
11 # Создаем DataFrame из словаря
12 df_users = pd.DataFrame(data , columns=[’Name’,
13 —> City ’ , ’ Age ’ ]) print(df.users)
14 # Вывод:
15 # Name City Age
16 # 0 Anna Moscow 25
17 # 1 Boris Minsk 33
18 # 2 Ivan New York 57
19 it 3 Chon Shanghai 45
20 # 4 Alice London 17
В данном примере мы создали объект DataFrame из словаря, где клю-
чи словаря используются в качестве меток столбцов, а значения — в качестве
данных. Если при создании объекта DataFrame в параметре columns указать
список столбцов, то в датафрейме будут только эти столбцы, а остальные бу-
дут проигнорированы. Если в словаре есть ключи, для которых нет значений,
то в соответствующих ячейках датафрейма будут значения NaN (Not a Number),
что обозначает пропущенные значения. Каждой строке объекта DataFrame при-
сваивается индекс, который ио умолчанию является числовым и начинается
с нуля.
Объект DataFrame имеет множество полезных атрибутов и методов, кото-
рые облегчают работу с данными. В таблице 6.3 приведены основные атрибуты
объекта DataFrame.
Таблица 6.3: Основные атрибуты объекта DataFrame библиотеки pandas
Атрибут Описание
values Возвращает массив NumPy, содержащий дан- ные DataFrame.
columns Возвращает индекс (метки столбцов) DataFrame.
□.ndex Возвращает индекс (метки строк) DataFrame.
dtypes Возвращает типы данных каждою столбца DataFrame.
shape Возвращает форму (размер) DataFrame в виде кортежа (количество строк, количество столб- цов).
size Возвращает общее количество элементов в DataFrame.
ndim Возвращает количество измерений DataFrame (всегда 2 для DataFrame).
empty Возвращает True, если DataFrame пустой.
axes Возвращает список осей (индексов) DataFrame.
memory_usage() Возвращает информацию об использовании па- мяти DataFrame.
В таблице 6.1 приведены наиболее часто используемые методы объекта
’ataFrame
Таблица 6.4: наиболее часто используемые методы объекта DataFrame библио-
теки pandas
Метод Описание
head(n) Возвращает первые п строк DataFrame
tail(n) Возвращает последние п строк DataFrame
described Возвращает описание статистик для каждого столбца DataFrame
Метод Описание
infо() Выводит краткую информацию о DataFrame, включая типы данных и количество ненуле- вых значений
mean О Возвращает среднее значение для каждого столбца DataFrame
sum О Возвращает сумму значений для каждого столбца DataFrame
min() Возвращает минимальное значение для каж- дого столбца DataFrame.
max() Возвращает максимальное значение для каж- дого столбца DataFrame.
std() Возвращает стандартное отклонение для каждого столбца DataFrame
var() Возвращает дисперсию для каждого столбца DataFrame
count 0 Возвращает количество ненулевых значений для каждого столбца DataFrame
uniqueO Возвращает уникальные значения для каждо- го столбца DataFrame
nuni que () Возвращает количество уникальных значений для каждого столбца DataFrame.
value_counts() Возвращает количество уникальных значений для каждого столбца DataFrame.
apply(func) Применяет функцию func ко всем элементам DataFrame
applymap(func) Применяет функцию func ко всем элементам DataFrame и возвращает новый DataFrame.
dropna(<параметры>) Удаляет пропущенные значения из DataFrame
f i1Ina(<паракетры>) Заменяет пропущенные значения в DataFrame на указанное значение value.
astype(type) Преобразует тин данных элементов DataFrame в указанный тип type
reset_index(<параметры>) Сбрасывает индексы DataFrame и возвращает новый DataFrame с новым индексом.
Метод Описание
set_index(<параметры>) Устанавливает индекс DanaFrame из указан- ных столбцов keys
rename (<параметры->) Переименовывает метки индекса и столбцов в DataFrame
reindex(<параметры>) Изменяет индексы DataFrame согласно новым меткам labels.
isnullO Возвращает булеву таблицу, указывающую на пропущенные значения в DataFrame
notnullO Возвращает булеву таблиц}', указывающую на ненулевые значения в DataFrame
Для применения (вызова) методов и атрибутов объекта DataFrame можно
использовать точечную нотацию.
Листинг 6.6: Пример применения методов и атрибутов объекта DataFrame
1
2
3
4
в
7
8
9
10
11
12
13
14
15
16
17
18
# Подключаем библиотеку pandas
import pandas as pd
# Создадим объект DataFrame
data = {
’Name’: (’Anna’, ’Boris’, ’Ivan’, ’Chen’, ’
>—> Alice ’] ,
’City’: [’Moscow’, ’Minsk’, ’New York’, ’
-4 Shanghai’, ’London’],
’Age’: [25, 33, 57, 45, 17]
}
# Создадим DataFrame из словаря
df = pd.DataFrame(data)
# Выведем количество строк и столбцов DataFrame
print(df.shape) # Вывод: (5, 3)
w Выведем информацию о DataFrame
print(di.inf о ())
# Вывод:
# <class ’pandas.core.frame.DataFrame’>
# Rangeindex: 5 entries, 0 to 4
19
20
21
22
23
24
25
20
27
28
29
# Data
# #
#----
# О
# 1
# 2
dtypes
memo ry
columns (total 3 columns):
Column Non-Null Count Dtype
Name 5 non-null object
City 5 non-null object
Age 5 non-null int64
int64 ( 1) , obj ect (2)
usage: 252.0+ bytes
# Рыведем индексы столбцов DataFrame
print(df.columns)
# Вывод: Index([’Name’ , ’City’, ’Age’],
<—> dtype=’object’)
§6.2. Загрузка и сохранение данных
Библиотека pandas предоставляет функции для импорта данных из раз-
личных форматов файлов. Для каждого типа файла существует отдельная
функция, доступная на верхнем уровне библиотеки.
Данные, предназначенные для обработки и анализа, часто хранятся
в файлах различных форматов. Один из наиболее распространенных форма-
тов CSV (Comma Separated Values), который представляет собой текстовый
файл табличного вида, где значения ячеек в строках разделены заданным сим-
волом (например, запятой или точкой с занятой). Также часто используются
файлы в формате Excel.
Рассмотрим методы загрузки данных из различных форматов файлов
и их выгрузки в файл. Для работы с файлами Excel (с расширениями .xlsx
или . xls) в библиотеке pandas требуется дополнительная библиотека openpyxl
Эта библиотека предоставляет функциональность для чтения и записи данных
в формате Excel. Для установки openpyxl выполните следующую команду:
Листинг 6.7: Установка библиотеки openpyxl
1 pip install openpyxl
Далее для загрузки данных из файлов в формате CSV можно исполь-
зовать функцию read, .csv О, а для файлов Excel функцию read..excelО.
Книга Excel может состоять из нескольких листов, поэтому можно указать на-
звание нужного нам листа (по умолчанию загружается первый лист):
Синтаксис функции read_excel() выглядит следующим образом:
Листинг 6.8: Синтаксис функции read_excel()
1 pd.read.excel(iо, sheet_name-0, header-0, names^None,
2 index_ccl = Nune, usecols-Kone , engine-None, «—>
<—> ciinverters = None ,
з dtype = None , skiprows = None , nrows=None ,
na.values=None ,
4 keep.default_na=True, verbose=False)
где:
• io путь к файлу Excel или объект, содержащий данные;
• sheet_name название листа, который нужно загрузить (но умолчанию
О, то есть первый лист);
• header — строка, содержащая заголовки столбцов (по умолчанию 0, то
сеть первая строка);
• names список названий столбцов, если они отсутствуют в файле;
• index_coJ столбец, который будет использоваться в качестве индекса
(ио умолчанию None, то есть индекс не устанавливается);
• usecols список столбцов, которые нужно загрузить (по умолчанию
None, то есть загружаются все столбцы);
• engine движок для чтения файла (по умолчанию None, то есть исполь-
зуется движок по умолчанию);
• converters — словарь, где ключи — названия столбцов, а значения
функции для преобразования данных в этих столбцах;
• dtype — тип данных для каждого столбца (по умолчанию None, то есть
типы данных определяются автоматически);
• skiprows количество строк, которые нужно пропустить в начале файла
(по умолчанию None, то есть не пропускаются);
• nrows — количество строк, которые нужно 3ai рузпть (ио умолчанию None,
то есть загружаются все строки);
• na_values — список значений, которые будут интерпретироваться как
пропущенные (NaN);
• keep_def ault_na - если True, то будут использоваться значения по умол-
чанию для пропущенных значений (по умолчанию True);
• verbose — если True, то будет выведена дополнительная информация
о процессе загрузки данных (по умолчанию False).
Для начала создадим файл Excel с данными, которые мы будем за-
гружать. Датес мы будем использовать этот файл для загрузки данных
в DataFrame. Создадим файл Laptops .xlsx с одним листом Computers и следу-
ющими данными:
Таблица 6.5: Лист Computers книги Laptops.xlsx
ID Company Inches Weight Price
1 Apple 13.3 1.37 kg 133 900.00 rub
2 Apple 13.3 1.34 kg 89 800.00 rub
3 HP 15.6 1.86 kg 57 500.00 rub
4 Apple 15.4 1.83 kg 253 700.00 rub
5 Apple 13.3 1.37 kg 188 300.00 rub
6 Acer 15.6 2.1 kg 10 000.00 rub
7 Apple 15.4 2.0 kg 213 900.00 rub
8 Apple 13.3 1.34 kg 115 800.00 rub
9 Asus 14 1.3 kg 119 500.00 rub
10 Acer 14 1.6 kg 77 000.00 rub
11 HP 15.6 1.86 kg 60 000.00 rub
ID Company Inches Weight Price
12 HP 15.6 1.8 kg 75 000.00 rub
13 Apple 15.4 1.37 kg 155 000.00 rub
14 Dell 15.6 2.3 kg 55 000.00 rub
15 Apple 12 1.2 kg 184 000.00 rub
16 Apple 13.3 1.37 kg 190 000.00 rub
17 Dell 15.6 2.3 kg 56 000.00 rub
18 Apple 15.4 1.34 kg 124 000.00 rub
19 Lenovo 15.6 1.8 kg 103 000.00 rub
20 Dell 13.3 2-3 kg 80 000.00 rub
Загрузим данные из файла Laptops.xlsx с помощью функции
read_excel()
Листинг 6.9: Загрузка данных из книги Excel с указанием листа
1 # Подключаем библиотеку pandas
2 import pandas as pd
з # Загрузка данных из файла Excel
4 df = pd.read.excel(’Laptops.xlsx ’ ,
s sheet_nac:e = ’ Computers ’)
e Я сыводим nej. ibie 5 строк загруженного DataFrame
7 print(df headO)
8 9 # вывод:
# ID Company Inches Weight Price
10 # 0 1 Apple 13.3 1.37 kg 1339O0.00 rub
11 # 1 2 Apple 13 3 1.34 kg 89800.00 rub
12 # 2 3 HP 15.6 1.86 kg 57500.00 rub
13 # 3 4 Apple 15.4 1.83 kg 253700.00 rub
14 # 4 5 Apple 13.3 1.37 kg 188300.00 rub
Для проверки корректности загрузки файла мы можем вывести первые
несколько строк загруженного DataFrame с помощью метода headO- Метод
headO ио умолчанию выводит первые 5 строк, но можно указать любое другое
количество строк, передав его в качестве аргумента. Если в файле Excel нет
заголовков столбцов, то можно указать параметр header=None, чтобы pandas
не пытался использовать первую строку как заголовки. Также можно исполь-
зовать метод infoO, который выведет информацию о загруженном DataFrame,
включая количество строк, столбцов и типы данных.
Листин! 6.10: Получаем информацию о DataFrame с помощью метода inf . О
I
2
3
|
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Подключаем библиотеку pandas
import pandas as pd
# Загрузка данных из файла Excel
df = pd.read.excel(’Laptops.xlsx’ ,
sheet_name=’Computers’)
# Получаем информацию о DataFrame
df.infо()
# Вывод:
# <class ’pandas core,frame DataFrame’>
# Rangeindex: 20 entries, 0 to 19
# Data columns (total 5 columns):
# # Column Non-Null Count Dtype
# ---------- ----------------- ------
0 ID 20 non-null int64
1 Company 20 non-null object
» 2 Inches 20 non-null float64
# 3 Weight 20 non-null object
# 4 Price 20 non-null object
# dtypes: float64(l), int64(l), object(,3)
# memory usage: 888.0+ bytes
Для загрузки данных из других форматов файлов, таких как CSV, JSON,
HTML. XML и других, pandas предоставляет аналогичные функции. В табли-
це 6.6 приведены основные методы для загрузки данных в объект DataFrame
библиотеки pandas.
Таблица 6.6: Основные методы для загрузки данных в DataFrame библиотеки
pandas
Метод Описание
геас!_сзу(<параметры>) Чтение данных из CSV’ файла. Парамет- ры включают путь к файлу, разделитель, заголовки, типы данных, обработку про- пущенных значений и многое другое.
геаб_ехсе1(<параметры>) Чтение данных из Excel файла. Парамет- ры включают путь к файлу, имя листа, за- головки, типы данных, обработку пропу- щенных значений и многое другое.
read.sql(<параметры>) Чтение данных из SQL запроса. Пара- метры включают SQL запрос, соединение с базой данных, индексные столбцы, типы данных и многое другое.
read_json(<парамегры>) Чтение данных из JSON файла или стро- ки. Параметры включают путь к файлу или строку JSON, ориентацию данных, ти- пы данных, обработку дат и многое дру- гое.
read_h.tml (<параметры>) Чтение данных из HTML таблиц. Пара- метры включают URL или строку HTML, шаблон для поиска таблиц, заголовки, ин- дексные столбцы и многое другое.
read.xml(<параметры>) Чтение данных из XML файла. Парамет- ры включают путь к файлу, XPath выра- жение для выбора данных, пространства имен, кодировку и многое другое.
read_stata(<napaMeTpH>) Чтение данных из Stata файла. Парамет- ры включают путь к файлу, обработку дат, категориальных данных, кодировку и многое другое.
Метод Описание
read_hdf(<параметры>) Чтение данных из HDF5 файла. Парамет- ры включают путь к файлу, ключ для до- ступа к данным, режим открытия файла и многое другое.
read.sas(<параметры>) Чтение данных из SAS файла. Парамет- ры включают путь к файлу, формат фай- ла, индексные столбцы, кодировку и мно- гое другое.
read_spss(<параметры>) Чтение данных из SPSS файла. Парамет- ры включают путь к файлу, столбцы для чтения, обработку дат и категориальных данных, кодировку и многое другое.
read_gbq(«параметры?) Чтение данных из Google BigQuery. Пара- метры включают SQL запрос, идентифи- катор проекта, индексные столбцы, обра- ботку типов данных и многое другое.
Для сохранения данных из объекта DataFrame в файл можно использо-
вать методы, которые позволяют экспортировать данные в различные форма-
ты.
Сохраним данные из объекта DataFrame в файл CSV с помощью метода
to_csv().
Листинг 6.11: Сохранение данных в файл CSV
1 # Подключаем библиотеку pandas
2 import pandas as pd
з # Загрузка данных из файла Excel
4 df = pd.read_excel(’tape .ps-xlsx ’ ,
s sheet_name=’Computers’)
ь » Сохраним DataFrame в файл CSV
? df . to .csv (’ Laptops . csv ’ , index=False,
c—> encoding=’utf 8 ’)
В данном примере мы загружаем данные из файла Excel в объект
DataFrame и затем сохраняем его в файл CSV с помощью метода to..csv().
Параметр index=False указывает, что индексы строк нс должны сохранять-
ся в файл, а параметр encoding=’utf8’ указывает кодировку файла. Если
вы хотите сохранить индексы строк в файл, то можно установить параметр
index=True или просто по указывать его. так как по умолчанию индексы со-
храняются.
Excel, обладая широким функционалом, иногда некорректно обрабаты-
вает данные. Например, при открытии или сохранении файла он может ав-
томатически преобразовывать строковые данные, похожие на даты (например,
числа, разделенные точками), в формат даты. Это может привести к потере или
искажению данных. Кроме того, формулы в таблицах Excel могут неправильно
отображаться при экспорте данных. В связи с этими особенностями загрузка
и обработка данных из файлов Excel в pandas может быть затруднена. Для
удобства хранения и обработки данных рекомендуется сначала конвертировать
таблицы Excel в формат CSV, который более стабилен и предсказуем для об-
работки данных.
Для сохраненпя данных в другие форматы файлов, такие как Excel,
.ISON. HTML. XML и другие, библиотека pandas предоставляет аналогичные
методы. В таблице 6.7 приведены основные методы для сохранения данных из
объекта DataFrame библиотеки pandas.
Таблица 6.7: Основные методы для сохранения данных из DataFrame библио-
теки pandas
Метод Описание
Ъо_с8у(<параметры>) Сохранение DataFrame в CSV файл. Пара- метры включают путь к файлу, раздели- тель, представление пропущенных значе- ний, столбцы для сохранения, заголовки, индексы и многое другое.
Метод Описание
to.excel(<параметры>) Сохранение DataFrame в Excel файл. Па- раметры включают путь к файлу, имя листа, представление пропущенных значе- ний, столбцы для сохранения, заголовки, индексы и многое другое.
to_sql(<параметры>) Сохранение DataFrame в SQL таблицу. Па- раметры включают имя таблицы, соеди- нение с базой данных, схему, обработку существующих таблиц, индексы, размеры пакетов и многое другое.
to_json(<napaMeTpH>) Сохранение DataFrame в JSON файл или строку. Параметры включают путь к фай- лу или строку JSON. ориентацию данных, формат даты, точность для чисел с плава- ющей точкой и многое другое.
to.html(<параметры>) Сохранение DataFrame в HTML таблицу. Параметры включают путь к файлу или буфер, столбцы для сохранения, заголов- ки, индексы, представление пропущенных значений и многое другое.
to.xml(<параметры>) Сохранение DataFrame в XML файл. Па- раметры включают путь к файлу, корне- вой элемент, имя строки, столбцы для ат- рибутов и элементов, пространства имен, кодировку и многое другое.
to_stata(<napaMeTpbi>) Сохранение DataFrame в Stata файл. Па- рамо гры включают путь к файлу, обработ- ку дат, индексы, кодировку, метки данных и переменных и многое другое.
to_hdf(<параметры>) Сохранение DataFrame в HDF5 файл. Па- раметры включают путь к файлу, ключ для доступа к данным, режим открытия файла, формат, индексы и многое другое.
Метод Описание
to.sas(<параметры>) Сохранение DataFrame в SAS файл. Па- раметры включают путь к файлу, формат файла, индексы, кодировку, формат даты и многое другое.
to.spss(<паракетры>) Сохранение DataFrame в SPSS файл. Па- раметры включают путь к файлу, индек- сы, кодировку, формат даты и многое дру- гое.
Сохраним данные из объекта DataFrame на двух разных листах файла
Excel с помощью метода to_excel()
Листинг 6.12: Сохранение данных на двух разных листах файла Excel
1 # Подключаем библиотеку pandas
2 import pandas as pd
з
4 я Загрузка данных из файла Excel
s df = pd.read_excel(’Laptops.xLsx ’ ,
6 sheet_name=’Computers’)
r # Сохраним DataFrame в файл Excel на двух разных лис<-^
тах
в with pd.ExcelWriter(’Laptops.Saved.xlsx’) as writer:
э df . to,exce 1 (writer , ej
sheet^name =’ Computers - f irst ’ , index = False)
io df . to.exce 1 (writer , *—
> sheet_name=’Computers - second’, index = False)
В данном примере мы загружаем данные из файла Excel в объект
DataFrame и затем сохраняем его на двух разных листах файла Excel с помощью
метода to_excel(). Мы используем контекстный менеджер ExcelWriter, кото-
рый позволяет записывать данные па несколько листов в одном файле Excel.
При этом мы указываем имя листа с помощью параметра sheet_name и уста-
навливаем параметр index=False. чтобы индексы строк не сохранялись в файл.
При работе с файлами в pandas, адрес файла может быть задан в одном
из следующих форматов:
• Относительный путь: указывается относительно текущей директории, на-
пример, ’data/Laptops.xlsx’
• Абсолютный путь: указывается полный путь к файлу на диске, например,
’С:/Users/Alexander/Documents/data/Laptops.xlsx’.
• URL: указывается ссылка на файл в интернете, например,
’https://example.com/data/Laptops.xlsx’. Важно, чтобы ссылка вела
непосредственно на содержимое файла.
По умолчанию в CSV файлах в качестве разделителя используется за-
пятая. Однако в некоторых регионах (например, в Европе) в качестве раздели-
теля может использоваться точка с запятой. В таких случаях необходимо явно
указать разделитель при загрузке данных с помощью аргумента sep функции
read.csv.
Аргумент encoding задает кодировку файла. По умолчанию использу-
ется кодировка utf-8. которая является стандартной для текстовых файлов.
Однако, если файл сохранен в другой кодировке (например, windows-1251 для
Windows в русскоязычных системах), необходимо явно указать ее при загрузке
данных.
При загрузке данных из интернета важно убедиться, что файл досту-
пен по прямой ссылке. Это означает, что веб-сервер должен возвращать только
содержимое файла без дополнительного форматирования, такого как HTML-
код, который может быть добавлен при отображении файла в веб-браузере.
Если файл доступен только через веб-интерфей с, который добавляет допол-
нительное форматирование, то загрузка данных напрямую в DataFrame мо-
жет быть невозможна. В таких случаях рекомендуется сначала загрузить файл
на локальный компьютер с помощью инструментов, таких как wget или curl,
а затем открыть его с помощью pandas.
§ 6.3. Описательная статистика
Описательная статистика в pandas позволяет быстро получить сводную
информацию о данных, такую как количество, среднее значение, стандартное
отклонение, минимум, максимум и другие статистические показатели. Для по-
лучения описательной статистики используется метод describe (), который воз-
вращает сводную таблицу с основными статистическими показателями для чис-
ловых столбцов в DataFrame Синтаксис метода describe О выглядит следую-
щим образом:
df.describe(percentiles=[0.25, 0 5, 0.75],
include=’number’,
exclude=’object’)
Листшп 6.13: Синтаксис метода describe()
1
2
3
где
• percentiles список процентилей, которые нужно включить в сводную
таблицу (по умолчанию используются 25%, 50% и 75%);
• include типы данных, которые нужно включить в сводную таблицу (по
умолчанию включаются только числовые столбцы, можно указать ’all’
для включения всех типов данных);
• exclude - типы данных, которые нужно исключить из сводной табли-
цы (по умолчанию исключаются столбцы с типом object, можно указать
’number’ для исключения числовых столбцов);
• df. describe О возвращает сводную таблицу с основными статистиче-
скими показателями для числовых столбцов в DataFrame.
Выберем из DataFrame описательную статистику для числовых столбцов.
Листинг 6.14: Получение описательной статистики с помощью метода
describe()
1
2
3
4
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
s data = {
e ’Company’; L’A’ , ’В’, ’С’, ’А’, ’В’],
7 ’Price’: [100, 200, 300, 100, 200]
8 }
э df = pd.DataFrame(data)
io # Получаем описательную статистику
и stats = df.describe()
12 print ( stats )
13 # Вывод:
14 # Price
15 # count 5.000000
16 # mean 200.000000
17 # std 100 000000
18 # min 100,000000
19 257. Ю0.О0000О
20 # 507. 200.000000
21 # 757. 200.000000
22 max 300 000000
В данном примере мы создаем DataFrame с двумя столбцами Company
и Price. Затем мы используем метод descri be О для получения описательной
статистики для числовых столбцов в DataFrame. Результатом будет сводная
таблица, содержащая количество значений, среднее значение, стандартное от-
клонение, минимум, 25%, 50% (медиана). 75% и максимум для столбца Price
Также можно получить описательную статистику для всех столбцов, включая
категориальные, используя параметр include=’all’. Выберем из DataFrame
описательную статистику для всех столбцов.
Листинг 6.15: Получение описательной статистики для всех столбцов с помо-
щью метода describe()
2
з
4
р Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
6 ’Compа п у ’ E’A’, ’B’ , ’C’ , ’A’ , ’ В ’ ] ,
7 8 ’Price 5 > : [100, 200, 300, 100, 200]
9 df = pd.DataFrame(data)
10 # Получаем описательную статистику для всех столбцов
11 stats = df . describe(include=’all’)
12 13 print(stats # Вывод: )
14 # Company Price
15 # count 5 5.000000
16 it unique 3 NaN
17 a top A 100.0
18 # freq 2 2 000000
19 » mean NaN 200,000000
20 # std NaN юо.оооооо
21 # min NaN 100.000000
22 # 257. NaN 100.000000
23 # 507. NaN 200.000000
24 # 757. NaN 200.000000
25 # max NaN 300.000000
В рассмотренном примере мы используем метод describe() с парамет-
ром include=>all’, чтобы получить описательную статистику для всех столб-
цов в DataFrame. Результатом будет сводная таблица, содержащая количество
значений, уникальные значения, наиболее часто встречающееся значение (top),
частоту этого значения (freq) для категориального столбца Company, а также
стандартные статистические показатели для числового столбца Price
Каждую функцпию, используемую для получения описательной стати-
стики, можно вызывать отдельно для получения конкретных статистических
показателей. В таблице G.8 приведены основные функции для получения опи-
сательной статистики в pandas.
Таблица 6.8: Основные функции описательной статистики библиотеки pandas
Функция Описание
mean(axis=O, skipna=True, numeric_only=True) Вычисление среднего значения для каж- дого столбца или строки
sum(axis=0, skipna=True, numeric_only=True) Вычисление суммы значений для каждого столбца или строки
min(axis=0, skipna=True, numeri c_only=True) Поиск минимального значения для каждо- го столбца или строки.
max(axis=0, skipna=True, numeric_only=True) Поиск максимального значения для каж- дого столбца или строки.
std(axis=0, skipna=True, ddof=l, numeric_only=True) Вычисление стандартного отклонения для каждого столбца или строки.
var(.axis=0, skipna-True, ddof=l, numeric_only=True) Вычисление дисперсии для каждого столбца или строки.
count(axis=O, numeri c_only=False) Подсчет количества ненулевых значений для каждого столбца пли строки.
median(axis=0, skipna=True, numeric_only=True) Вычисление медианы для каждого столб- ца или строки.
mode(axis=0, numenc_only=False, dropna-True) Поиск моды (наиболее часто встречающе- гося значения) для каждого столбца или строки.
quantile(q=0.5, axis-0, numeric_only=True, interpolat ion-’linear’) Вычисление квантиля для каждого столб- ца или строки.
skew(axis=O, skipna=True, numeric_only=True) Вычисление асимметрии для каждого столбца или строки.
Функция Описание
kurt(axis=0, skipna=True, numen c_only=True) Вычисление эксцесса (островершинности) для каждого столбца пли строки.
absO Вычисление абсолютных значений для каждого элемента DataFrame.
round(deciraals=O) Округление значений до указанного коли- чества десятичных знаков.
corr(methcd=’pearson’, min_penods=l, numeric_only=False) Вычисление корреляционной матрицы для DataFrame.
cov(min_periods=l, ddof=1, numeric_only=False) Вычисление ковариационной матрицы для DataFrame.
§ 6.4. Преобразование данных
Преобразование данных в pandas позволяет изменять структуру и фор-
мат данных, что полезно для подготовки данных к анализу и визуализации.
Преобразование данных может включать в себя операции, такие как изменение
типа данных, переименование столбцов, добавление новых столбцов, удаление
столбцов, изменение индекса и другие. Для преобразования данных в pandas
используются методы astypeO. renameO, assignO, dropO. ser_index()
и другие.
6.4.1. Изменение типа данных
Изменение типа данных в pandas позволяет преобразовывать столбцы
DataFrame в другие типы данных, что может быть полезно для оптимизации
памяти или подготовки данных к анализу. Для изменения типа. ;анных исполь-
зуется метод astypeO, который позволяет преобразовывать столбцы DataFrame
в указанный тип данных. Синтаксис метода astypeO выглядит следующим об-
разом:
Листинг 6.16: Синтаксис метода astypeO
—
1 df [ ’<столбец>’ ] = df [’<столбец>’1.astype(’<тип данные^
«-> х> ’ )
где
• <столбец> имя столбца, тип данных которого нужно изменить;
• <тип данных> — новый тип данных, в который нужно преобразовать стол-
бец (например, ’int’, 'float’, ’str’ и т.д.);
• astypeO метод, который используется для изменения тина данных
столбца;
• df Г’<столбец>’] = df [’<столбец>’] .astype(’<тил данных:*’) при-
сваивает преобразованный столбец обратно в DataFrame.
Выберем из DataFrame столбец Price и изменим его тип данных на int.
Листинг 6.17: Изменение тина данных с помощью метода astypeO
1
2
3
4
6
7
8
9
10
11
12
13
14
15
16
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: Г’А’, ’В’, ’С’, ’A’, ’B’],
’Price’: [100, 200, 300, 100, 200]
}
df = pd.DataFrame(data)
# Изменяем тип данных столбца Price на int
df[’Price '] = df[’Price’] astype(int)
print(df)
# Вывод:
# Company Price
# 0 A 100
# 1 В 200
17 # 2 С 300
18 # 3 А 100
19 # 4 В 200
В данном примере мы создаем DataFrame с двумя столбцами: Company
и Price. Затем мы используем метод astypeO для изменения типа данных
столбца Price на int При этом мы присваиваем преобразованный столбец об-
ратно в DataFrame. чтобы изменения вступили в силу.
6.4.2. Переименование столбцов
Переименование столбцов в pandas позволяет изменять имена столбцов
DataFrame, что может быть полезно для улучшения читаемости и понимания
данных. Для переименования столбцов используется метод rename (), который
позволяет изменять имена столбцов DataFrame на указанные новые имена. Син-
таксис метода rename О выглядит следующим образом:
Листинг 6.18: Синтаксис метода rename О
—
1 df , rename ( colunins = { ’ Сстарое имя>’: ’сновое имя> ’ } , ч->
<—> inplace = True)
где
• columns словарь, где ключи — старые имена столбцов, а значения
новые имена столбцов:
• inplace если True, то изменения применяются к исходному DataFrame,
иначе возвращается новый DataFrame;
• df.rename(columns=’<CTapoe имя>’: ’<новое имя>’, inplace=True)
переименовывает столбцы в DataFrame и применяет изменения к исходно-
му DataFrame
Выберем из DataFrame столбец Company и переименуем его в Firm
Листинг 6.19: Переименование столбцов с помощью метода rename О
1
2
3
4
в
7
8
9
10
11
12
13
14
15
16
17
18
19
29
21
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: L’A’, ’В’, ’С’, ’A’, ’B’],
’Price’: [100, 200, 300, 100, 200]
}
df = pd DataFrame(data)
# Переименовываем столбец Company в Firm
df.rename(columns={’Company’: ’Firm’}, inplace-True)
prinn(df)
вывод:
# Firm Price
# 0 А 100
» 1 В 200
2 С 300
3 А 100
4 Б 200
В данном примере мы создаем DataFrame с двумя столбцами: Company и Price
Затем мы используем метод rename () для переименования столбца Company
в Firm. При этом мы указываем словарь columns=’Company’: ’Firm’, где ключ
’Company’ — старое имя столбца, а значение ’Firm’ новое имя столбца.
Также мы указываем параметр inplace=True. чтобы изменения применялись
к исходному DataFrame. Если бы мы нс указали параметр inplace=True. то ме-
тод вернул бы новый DataFrame с переименованными столбцами, а исходный
остался бы неизменным.
6.4.3. Добавление новых столбцов
Добавление новых столбцов в pandas позволяет расширять DataFrar.e
новыми данными, что может быть полезно для создания новых признаков пли
вычисления дополнительных значений на основе существующих столбцов.
Для добавления новых столбцов используется два основных подхода:
прямое присваивание и метод assignO.
Прямое присваивание заключается в том. что мы просто создаем новый
столбец, присваивая ему значения на основе существующих столбцов. Синтак-
сис прямого присваивания выглядит следующим образом:
Листинг 6.20: Синтаксис прямого присваивания новых столбцов
/
1 df[’<HOBHH столбец>’] = <выражение>
где
• <новый столбец> имя нового столбца, который будет добавлен
в DataFrame;
• <выражение> выражение, которое вычис 1яег значения для нового столб-
ца на основе существующих столбцов;
• df[’<HOBbiil столбец>’] = <выражение> — присваивает новое значение
столбцу в DataFrame
Добавим новый столбец Discounted Price в DataFrame, который будет
равен цене со скидкой 10%.
Листинг 6.21: Прямое присваивание новых столбцов
1
2
3
4
5
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
6 ’Company’ [’А’, ’В’, ’С’, ’А’, ’В’],
т ’Price’: [100, 200, 300, 100, 200]
8 }
э df = pd DataFrame(data)
10
п # Добавляем новый столбец Discounted Price , который
—> равен цене со скидкой 10%
12 df [’ Discounted Price’] = df[’Price’J * 0.9
13
14 print(df)
15 # Вывод:
16 # Company Price Discounted Price
17 # 0 А 100 90.0
18 # 1 В 200 180.0
19 # 2 С 300 270.0
20 # 3 А 100 90.0
21 # 4 В 200 180.0
В примере мы создаем DataFrame с двумя столбцами: Company и Price
Затем мы добавляем новый столбец Discounted Price, который равен цене
со скидкой 10%. При этом мы присваиваем новый столбец df [’Discounted
Price’] значению df [’Price’] * 0.9, где df [’Price’] — существующий стол-
бец. a 0 9 коэффициент скидки.
Метод assign () позволяет добавлять новые столбцы в DataFrame с помо-
щью выражений, которые вычисляют значения для новых столбцов на основе
существующих столбцов. Синтаксис метода assign О выглядит следующим об-
разом:
Листинг 6.22: Синтаксис метода assignO
1 df.assign(**{’«новый столбец>’: «.выражение;»})
где
• <новый столбец> — имя нового столбца, который будет добавлен
в 'lataFrame;
• <выражение> выражение, которое вычисляет значения для нового столб-
ца на основе существующих столбцов.
Выберем из DataFrame столбец Price и добавим новый столбец
Discounted Price, который будет равен цене со скидкой 10%.
Листинг 6.23: Добавление новых столбцов с помощью метода assign ()
1
2
3
3
6
7
8
9
10
И
12
13
14
15
16
17
18
19
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: L’A’, ’В’, ’С’, ’A’, ’B’],
’Price’: [100, 200, 300, 100, 200]
}
df = pd DataFrame(data)
# Добавляем новый столбец Discounted Price , который е->
=-» равен цене со скидкой 10%
df = df.assign(**{’Discounted Price’: df[’Price’J * < ‘
0.9})
pr int(df)
# Вывод:
# Company Price Discounted Price
0 А 100 90.0
# 1 В 200 180.0
2 С 300 270.0
# 3 А 100 90.0
# 4 В 200 180.0
В приведенном примере мы создаем DataFrame с двумя столбцами:
Company и Price. Затем мы используем метод assign О для добавления но-
вого столбца Discounted Price, который равен цене со скидкой 10%. При этом
мы указываем словарь **’Discounted Price’: df [’Price’] * 0.9, где ключ
’Discounted Price’ — имя нового столбца, а значение df [’Price’] * 0 9
выражение, вычисляющее значения для нового столбца на основе сущеехвую-
шего столбца Price. Если необходимо добавить несколько новых столбцов, то
можно указать их в виде словаря, где ключи имена новых столбцов, а зна-
чения — выражения для вычисления значений. Выберем из DataFrame столбец
Price и добавим два новых столбца: Discounted Price и Price with Тах, где
Price with Tax будет равен цене с налогом 20%.
Листинг 6.24: Добавление нескольких новых столбцов с помощью метода
assignO
1 # Подключаем библиотеку pandas
2 3 4 5 6 7 8 9 import pandas as pd # Создаем DataFrame data = { ’Company’: [’А’, ’В’, ’С’, ’A’, ’B ’Price’: [100, 200, 300, 100, 200] df = pd.DataFrame(data) Я Добавляем два новых столбца Discount ’] , fed Price и
10 11 12 13 14 15 16 <-> Price with Tax df = df.assign (**{ ’Discounted Price’: df [’Price’] * ’Price with Tax’: dfl’Price’J * 1. }) print(df) # Вывод: # Company Price Discounted Price 0.9, 2 Price with Tax
17 18 19 20 21 #0 A 100 90.0 #1 В 200 1S0.0 #2 C 300 270.0 #3 A 100 90.0 #4 В 200 180.0 120.0 240 0 360.0 120,0 240.0
В данном примере мы создаем DataFrame с двумя столбцами: Company
и Price Затем мы используем метод assignO для добавления двух но-
вых столбцов: Discounted Price и Price with Тах. При этом мы указыва-
ем словарь **’Discounted Price’: df[’Price’] * 0.9, ’Price with Tax’:
df [’Price’] * 1.2, где ключи — имена новых столбцов, а значения — выра-
жения для вычисления значений.
6.1.4. Удаление столбцов
Удаление столбцов в pandas позволяет удалять ненужные столбцы из
DataFrame, что может быть полезно для очистки данных или подготовки их
к анализу. Для удаления столбцов используется метод drop С), который позво-
ляет удалять указанные столбцы из DataFrame. Синтаксис метода dropO вы-
глядит следующим образом:
Листинг 6.25: Синтаксис метода dropO
1 df,drop(columns=[’«столбец!>’, ’ <столбец2>’])
где
• columns список столбцов, которые нужно удалить из DataFrame,
• df .drop(соlumns=[’«столбец!>’, ’<столбец2>’]) — удаляет указанные
столбцы из DataFrame и возвращает новый DataFrame без этих столбцов.
Выберем из DataFrame столбец Discounted Price и удалим его.
Листинг 6.26: Удаление столбцов с помощью метода dropO
Z--------------------------------------------------------
1 # Подключаем библиотеку pandas
a import pandas as pd
3
4 # Создаем DataFrame
□ data = {
6 ’Company’: [’А’, ’В’, ’С’, ’A’, ’ B’] ,
7 ’Price’: [100, 200, 300, 100, 200],
s ’Discounted Price’: [90, 180, 270, 90, 180]
9 }
io df = pd . DataFrame (data)
и # Удаляем столбец Discounted Price
12 df = df.drop(columns=L’Discounted Price’])
13 print(df)
14 # Вывод:
15 # Company Price
16 # 0 A 100
17 # 1 В 200
18 2 C 300
19 # 3 A 100
20 # 4 В 200
В данном примере мы создаем DataFrame с тремя столбцами: Company,
Price и Discounted Price Затем мы используем метод dropO для удале-
ния столбца Discounted Price При этом мы указываем список столбцов
columns-[’Discounted Price’], которые нужно удалить из DataFrame При
этом мы присваиваем результат обратно в DataFrame, чтобы изменения вступи-
ли в силу. Если необходимо удалить несколько столбцов, то можно указать их
в виде списка.
6.4.5. Изменение индекса
Изменение индекса в pandas позволяет изменять индекс DataFrame. что
может быть полезно для упорядочивания данных или создания нового индекса
на основе существующих столбцов. Для изменения индекса используется метод
set_index(), который позволяет устанавливать новый индекс для DataFrame
на основе указанных столбцов. Синтаксис метода set_index() выглядит сле-
дующим образом:
Листинг 6.27: Синтаксис метода set_index()
1 df . set_index(keys = [’Сстолбец!>’, ’<столбец2>’J, >
—» drop = True , inplace = True )
где
• keys список столбцов, которые будут использоваться в качестве нового
индекса;
• drop если True, то указанные столбцы будут удалены из DataFrame,
иначе они останутся в DataFrame;
• inplace если True, то изменения применяются к исходному DataFrame,
иначе возвращается новый DataFrame.
Выберем из DataFrame столбец Company и установим его в качестве нового
индекса.
Листинг 6.28: Изменение индекса с помощью метода set_indexO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: [’А’, ’В’, ’С’, ’A’, ’В ’ ] ,
’Price’: [100, 200, 300, 100, 200]
df = pd.DataFrame(data)
# Устанавливаем столбец Company в качестве нового ин^
декса
df.set_index(keys=[’Company’], drop=True,
inplace = True)
print(df)
# Вывод:
Price
a Company
it A 100
# В 200
C 300
a A 100
В 200
В рассмотренном примере мы создаем DataFrame с двумя столбцами:
Company и Price Затем мы используем метод set_index() для установки столб-
ца Company в качестве нового индекса. При этом мы указываем список столбцов
keys=[’Company’], которые будут использоваться в качестве нового индекса,
и параметр drop=True. чтобы удалить столбец Company из DataFrame. Если
необходимо установить несколько столбцов в качестве нового индекса, то мож-
но указать их в виде списка. Выберем из DataFrame столбцы Company и Price
и установим их в качестве нового индекса.
Листинг 6.29: Изменение индекса с помощью метода set_index() с несколькими
столбцами
1 # Подключаем библиотеку pandas
2 import pandas as pd
3
4 # Создаем DataFrame
s data = {
6 ’Company’: [’А’, ’В’, ’С’, ’A’, ’B’],
7 ’Price’: [100, 200, 300, 100, 200],
s ’Discounted Price’: [90, 180, 270, 90, 180]
9 }
io df = pd . DataFrame (data)
n # Устанавливаем столбцы Company и Price в качестве не-»
«-> ового индекса
12 df . set_index ( keys = [’ Company ’ , ’Price’], drop-True,
*—> inplace = True)
13 print(df)
14 # Зывод:
15 # Discounted Price
16 # Company Price
17 # A 100 90
18 # В 200 180
19 # C 300 270
20 # A 100 90
21 # В 200 180
22 # C 300 270
В примере мы создаем DataFrame с тремя столбцами: Company. Price
и Discounted Price Затем мы используем метод set_index() для установки
столбцов Company и Pri се в качестве нового индекса. При этом мы указыва-
ем список столбцов keys=[’Company’, ’Price5], которые будут использовать-
ся в качестве нового индекса, и параметр drop=True, чтобы удалить столбцы
Company и Price из DataFrame.
6.4.6. Преобразование данных с помощью метода applyO
Метод applyO в pandas позволяет применять функции к строкам или
столбцам DataFrame. что может быть полезно для выполнения сложных преоб-
разований данных. Синтаксис метода applyO выглядит следующим образом:
Листинг 6.30: Синтаксис метода applyO
1 df . apply (func , axis = 0, raw = Falsc , <-»
<—> result\_type-None , args = (), **kwds)
где
• func функция, которая будет применяться к строкам или столбцам
DataFrame;
• axis ось, но которой будет применяться функция: 0 для столбцов (ио
умолчанию) и 1 для строк;
• raw если True, то функция будет применяться к массивам NuinPy, иначе
к объектам Series;
• result_type тин результата, который будет возвращаться: ’expand’
для расширения результата в несколько столбцов, ’reduce’ для уменьше-
ния результата до одного столбца, ’broadcast’ для расширения резуль-
тата до исходной формы DataFrame; •
• args дополнительные аргументы, которые будут переданы функции;
• **kwds — дополнительные именованные аргументы, которые будут пере-
даны функции.
Выберем из DataFrame столбец Price и применим к нему функцию, ко-
торая будет умножать каждое значение па 2.
Листинг 6.31: Преобразование данных с помощью мстодгг applyO
1
2
3
4
5
6
7
3
9
10
11
12
13
11
15
10
17
18
19
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’ L’A’, ’В’, ’C’, ’A’, ’B’J,
’Price’: [100, 200, 300, 100, 200]
}
df = pd.DataFrame(data)
# Применяем функцию, которая умножает каждое значений—1
е в столбце Price на 2
df[’Price’] = df[’Price’].apply(lambda x: x * 2)
print(df)
# Вывод:
# Company Price
# 0 А 200
# 1 В 400
а 2 С 600
я 3 А 200
4 В 400
В рассмотренном примере мы создаем DataFrame с двумя столбцами:
Company и Price Затем мы используем метод applyO для применения функ-
ции, которая умножает каждое значение в столбце Price па 2 При этим мы
передаем лямбда-функцию lambda х: х * 2 в качестве аргумента func метода
apply (). Функция applyO применяет эту лямбда-функцию к каждому значе-
нию в столбце Price и возвращает новый столбец с преобразованными значе-
ниями. Если необходимо применить функцию к строкам DataFrame. то мож-
но указать параметр axis=l. Выберем из DataFrame столбцы Price и Company
п применим к ним функцию, которая будет объединять значения в строку.
Листинг 6.32: Преобразование данных с помощью метода applyO к строкам
1 # Подключаем библиотеку pandas
2 import pandas as pd
з
4 # Создаем DutaFra e
s data = {
e ’Company’- [’А’, ’В’, ’С’, ’A’, ’B’],
7 ’Price’: [100, 200, 300, 100, 200]
8 }
э df = pd.DataFrame(data)
io # Применяем функцию, которая объединяет значения в се^
М- троку
и df[’Combined’] = df.apply(lambda row: e
W f "{row[ ’Company’ ] }: {row [’Price’]}-", axis»!)
12 13 14 print(df ) # Вывод: # Company Price Combined
15 # 0 A 200 A : 200
16 # 1 В 400 B: 400
17 # 2 C 600 C: 600
18 # 3 A 200 A : 200
19 # 4 В 400 В : 400
В данном примере мы создаем DataFrame с двумя столбцами Company
и Price Затем мы используем метод applyO для применения функции, ко-
торая объединяет значения в строку. При этом мы передаем лямбда-функцию
1 ambda row: f "row [ ’ Company ’ ] : row [’Price’]" в качестве аргумента f unc ме-
тода applyO и указываем параметр axis=l, чтобы функция применялась
к строкам DataFrame. Функция applyO применяет эту лямбда-функцию к каж-
дой строке DataFrame и возвращает новый столбец Combined с объединенными
значениями
§ G.5. Фильтрация данных
Фильтрация данных в pandas это процесс выбора подмножества дан-
ных (строк или/и столбцов) па основе определенных условий. Она позволяет
извлекать только тс данные, которые нам нужны для анализа.
Основные подходы к фильтрации данных в pandas включают:
• Фильтрация по меткам: позволяет выбрать строки и столбцы по их меткам
(именам).
• Фильтрация по позициям (индексам): позволяет выбрать строки и столб-
цы по их позициям (индексам).
• Фильтрация по значениям: позволяет выбрать строки и столбцы, которые
содержат определенные значения.
* Фильтрация по диапазону: позволяет выбрать строки и столбцы, которые
содержат значения в определенном диапазоне.
• Фильтрация по типам данных: позволяет выбрать строки и столбцы, ко-
торые содержат определенные типы данных.
* Фильтрация по уникальным значениям: позволяет выбрать строки
и столбцы, которые содержат уникальные значения.
• Фильтрация по дубликатам: позволяет выбрать строки и столбцы, кото-
рые содержат дубликаты.
• Фильтрация но пропущенным значениям: позволяет выбрать строки
и столбцы, которые содержат пропущенные значения.
• Фильтрация по регулярным выражениям: позволяет выбрать строки
и столбцы, которые соответствуют определенному шаблону.
* Филы рация по нескольким условиям (логическим выражениям): позво-
ляет выбрать строки и столбцы, которые соответствуют нескольким усло-
виям одновременно.
Для реализации фильтрации данных в pandas используются методы
п атрибуты объекта DataFrame, такие как loc, iloc, query, filter и другие.
В таблице 6.9 приведены основные методы для фильтрации данных из объекта
DataFrame библиотеки pandas.
Таблица 6.9: Основные методы для фильтрации данных из DataFrame библио-
теки pandas
Метод Описание
f 111 er ( < параметры:*) Фильтрация столбцов по меткам.
query(<параметры>) Фильтрация строк с использованием строко- вого выражения.
1ос[] Доступ к группе строк и столбцов по меткам или булсвому массиву.
1sin(<паранетр>) Фильтрация данных на основе значений, со- держащихся в списке. Возвращает DataFrame булевых значений, указывающих, содержится ли каждое значение в списке.
drop(<параметры>) Удаление строк или столбцов по меткам.
dropna(«параметры*) Удаление строк или столбцов с пропущенны- ми значениями
fillna(«параметры*) Заполнение пропущенных значений указан- ным значением.
replace(«параметры*) Замена значений в DataFrame.
duplicated(«параметры*) Возвращает булеву серию, указывающую на дублирующиеся <троки.
drop_dupli cat es(«па раметры>) Удаление дублирующихся строк.
nlargest («.параметры.*) Возвращает первые и строк с наибольшими значениями в указанных столбцах.
nsmallesr («параметры!») Возвращает первые п строк с наименьшими значениями в указанных столбцах.
sort.values(«параметры*) Сортировка строк по значениям в указанных столбцах.
sort.index(«параметры*) Сортировка строк по значениям индекса.
where(«параметры*) Замена значений, по соответствующих усло- вию, па указанное значение.
Метод Описание
mask(<параметры>) Замена значений, соответствующих условию, на указанное значение.
sample(<параметры>) Случайная выборка строк или столбцов.
Также для фильтрации данных в pandas используются булевы массивы,
которые позволяют выбирать строки и столбцы на основе логических условий.
6.5.1. Фильтрация по меткам и позициям
Фильтрация по меткам и позициям позволяет выбирать строки и столбцы
в DataFrame на основе их меток (имен) пли позиций (индексов). Для фильтра-
ции по меткам или логическим условиям используется метод 1ос Метод iloc
считается устаревшим и не рекомендуется к использованию. Синтаксис метода
1ос выглядит следующим образом:
Листинг 6.33: Синтаксис метода 1ос
1 df.1ос[<строки>, <столбцы>]
где
• строки метки строк, которые нужно выбрать (можно использовать сре-
зы. списки или булевы массивы);
• столбцы метки столбцов, которые нужно выбрать (можно использовать
срезы, списки или булевы массивы).
Выберем из DataFrame строки с метками 0. 1 и 2, а также столбцы
Company и Prj се.
Листинг 6.34: Фильтрация по меткам с помощью метода 1ос
—
1 # Подключаем библиотеку pandas
2 import pandas as pd
3
4
5
6
7
8
9
10
11
12
13
14
15
1G
17
18
# Создаем DataFrame
data = {
’Company’: [’А’ , ’В’ , ’ С ’ , ’D’] ,
’Price’: [100, 200, 300, 400]
}
df = pd.DataFrame(data)
# Фильтруем строки и столбцы
filtered = df.loc[0:2, [’Company’, ’Price’]]
print(filtered)
# Вывод:
# Company Price
0 А 100
# 1 В 200
2 С 300
В данном примере мы создаем DataFrame с двумя столбцами: Company
п Price. Затем мы используем метод 1ос для фильтрации строк с метками 0, 1
и 2, а также столбцов Company и Price. Для этого мы передаем в метод 1ос срез
строк 0:2 и список столбцов [’Company’, ’Price’]. Результатом будет новый
DataFrame, содержащий только выбранные строки и столбцы.
6.5.2. Фильтрация по значениям и диапазону
Фильтрация по значениям и диапазону позволяет выбирать строки
и столбцы в DataFrame на основе значений в определенных столбцах. Для филь-
трации по значениям используется метод 1ос с булевыми массивами, которые
представляют собой логические условия. Синтаксис метода 1ос для фильтра-
ции по значениям выглядит следующим образом:
Листинг 6.35: Синтаксис метода 1ос для фильтрации по значениям
1 df.loc[df[’<столбец> ’ ] < <значение>, [ ’<столбец!>’,
’ <столбец2> ’ ] ]
где
• <столбец> имя столбца, по которому выполняется фильтрация;
• <значение> - значение, по которому выполняется фильтрация;
• <столбец1>, <столбец2> имена столбцов, которые нужно выбрать;
• df [’<столбец> ’] < <значение> — булев массив, который представляет
собой логическое условие для фильтрации строк.
Выберем из DataFrame строки, где цена меньше 300, и столбцы Company
и Price
Листинг 6.36: Фильтрация по значениям с помощью метода 1ос
i
2
3
4
5
t.
7
8
9
10
11
12
13
14
15
16
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’. L’A’, ’В’, ’C’, ’D’J,
’Price’: [100, 200, 300, 400]
df = pd.DataFrame(data)
# Фильтруем строки по значениям
filtered = df.loc[df[’Price ’] < 300, [’Company’, *<-»
e-> Price ’ ] ]
print(f iltered)
Бывид:
Company Price
0 А 100
1 В 200
В данном примере мы используем метод 1ос для фильтрации строк, где
цепа меньше 300, и выбираем столбцы Company и Price. Для этого мы исполь-
зуем булев массив df [ ’Price ’] < 300. который возвращает логическое условие
для фильтрация строк. При этом мы можем не указывать столбцы, если хотим
выбрать все столбцы, удовлетворяющие условию.
Для фильтрации по диапазону значений пли задания более сложных
условий фильтрации можно использовать логические операторы. В таблице 6.10
приведены основные логические операторы, которые можно использовать для
фильтрации данных из DataFrame.
Таблица 6.10: Основные логические операторы применимые к DataFrame биб-
лиотеки pandas
Оператор Описание
== Проверка на равенство.
1 = Проверка на неравенство.
> Проверка на больше.
< Проверка на меньше.
>= Проверка на больше или равно.
<- Проверка на меньше или равно.
& Логическое 11.
1 Логическое ИЛИ.
Логическое НЕ.
Выберем из DataFrame строки, где цепа больше 200 и меньше 400, и столб-
цы Company и Price.
Листинг 6.37: Фильтрация по диапазону значений с помощью метода 1ос
-------------------------------------------------------------
1 й Подключаем библиотеку pandas
2 import pandas as pd
3
4 # Создаем DataFrame
5 data = {
6 ’Company’: [’А’, ’В’, ’C’, ’D’J,
7 ’Price’: [100, 200, 300, 400]
s }
9 df = pd.DataFrame(data)
io # Фильтруем строки по диапазону значений
11
12
13
14
15
filtered = df . loc [(df [’Price ’ ] > 200) & <->
w (dfL’Price’J < 400), [’Company’, ’Price’]]
print(filtered)
# Вывод:
# Company Price
#2 C 300
В рассмотренном примере мы используем метод loc для фильтрации
строк, где цена больше 200 и меньше 400, и выбираем столбцы Company
и Price Для этого мы используем логическое условие (df[’Price’] > 200)
& (df [’Price’] < 400), которое возвращает булев массив, указывающий, ка-
кие строки удовлетворяют этому условию.
Зададим более сложное условие фильтрации, выберем строки, где цена
больше 200 и компания нс равна ’А’, и столбцы Company и Price
Листинг 6.38: Фильтрация по сложным логическим условиям с помощью метода
loc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
'Company*: [’A*, 'B', 'C', 'D'],
'Price’: [100, 200, 300, 400]
J
df = pd.DataFrame(data)
# Фильтруем строки по сложным логическим условиям
filtered = df.loc[(df[’Price ’ ] > 200)
& (df [' Company ' ] != 'A'), <-->
> ['Company', 'Price’]]
print(filtered)
Вывод:
a Company Price
# 2 C 300
# 3 D 400
6.5.3. Фильтрация ио уникальным значениям и дубликатам
Фильтрация по уникальным значениям и дубликатам позволяет выби-
рать строки и столбцы в DataFrame на основе уникальности значений в опреде-
ленных столбцах. Для фильтрации по уникальным значениям используется ме-
тод drop_duplicares(), который удаляет дублирующиеся строки в DataFrame
Синтаксис метода drop_duplicates() выглядит следующим образом:
Листинг 6.39: Синтаксис метода drop_duplicatesO
—
1 df,drop_duplicates(subset=[’<столбец1>’, ’«столбец^
с-> 2>’J, keep=’first ’ , inpl ace = True )
где
• subset список столбцов, по которым выполняется фильтрация;
• keep — параметр, определяющий, какие дубликаты сохранять (по умол-
чанию ’first’ сохраняет первый вхождение, ’last’ сохраняет по-
следнее вхождение, False удаляет все дубликаты);
• inplace — если True, то изменения применяются к исходному DataFrame,
иначе возвращается новый DataFrame.
Выберем из DataFrame уникальные значения в столбце Company и удалим
дубликаты.
Листинг 6.40: Фильтрация ио уникальным значениям с помощью метода
drop_duplicates()
1
2
3
4
5
6
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company*: [’А’, >B>, *C’, ’A’, ’B>],
7
Ч
9
10
11
12
13
14
15
16
17
’Price’: [100, 200, 300, 100, 2001
}
df = pd.DataFrame(data)
# Удаляем дубликаты
df.drop_duplicates(subset=[’Company’], <->
keep = ’first ’ , inpJ ace = True)
print(df)
# Вывод:
# Company Price
it 0 A 100
# 1 В 200
it 2 C 300
В рассмотренном примере мы создаем DataFrame с двумя столбца-
ми: Company и Price. Затем мы используем метод drop_duplicates() для
удаления дубликатов в столбце Company При этом мы указываем параметр
subset= [’Company ’], чтобы фильтровать только по этому столбцу, параметр
keep-’first’, чтобы сохранить первое вхождение, и параметр inplace=True.
чтобы изменения применялись к исходному DataFrame Если бы мы не указали
параметр inplace=True. то метод вернул бы новый DataFrame с уникальными
значениями, а исходный остался бы неизменным. Для фильтрации по дублика-
там можно использовать метод duplicated О, который возвращает булев мас-
сив. указывающий па дублирующиеся строки в DataFrame. Синтаксис метода
duplicatedO выглядит следующим образом:
Листинг 6.41: Синтаксис метода duplicatedO
7--------------------------------------------------------
1 df.duplicated(subset=[’<столбец1>’, ’<столбец2>’],
keep=’first’)
где
• subset список столбцов, по которым выполняется фильтрация;
• keep параметр, определяющий, какие дубликаты сохранять (ио умол-
чанию ’first’ сохраняет первый вхождение, ’last’ сохраняет по-
следнее вхождение, False удаляет все дубликаты).
Выберем из DataFrame дублирующиеся строки в столбце Company.
Листинг 6.42: Фильтрация по дубликатам с помощью метода duplicated О
1
2
3
<1
6
7
8
9
10
11
12
13
14
15
1в
17
18
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: L’A’, ’В’, ’C’, ’A’, ’B’J,
’Price’: [100, 200, 300, 100, 200]
df = pd .':ataFrame (data)
я Получаем булев массив дублирующихся строк
duplicates = df.duplicated(subset=[’Company’],
keep= ’ first ’ )
print(duplicates)
# Вывод:
# 0 False
# 1 False
# 2 False
# 3 True
я 4 True
В данном примере мы создаем DataFrame с двумя столбцами: Company
и Price Затем мы используем метод duplicatedO для получения булевого
массива, указывающего па дублирующиеся строки в столбце Company При этом
мы указываем параметр subset= [’Company ’]. чтобы фильтровать только по
этому столбцу, и параметр keep=’first’, чтобы сохранить первое вхождение.
Результатом будет булев массив, где True указывает на дублирующиеся строки,
a False - на уникальные строки.
Если необходимо получить только уникальные значения в столбце, то
можно использовать метод unique(), который возвращает массив уникальных
значений в указанном столбце. Синтаксис метода unique () выглядит следую-
щим образом:
Листинг 6.43: Синтаксис метода unique()
1 df[’<столбец>’]•unique()
где
• <столбец> имя столбца, для которого нужно получить уникальные зна-
чения;
• df [’<стол6ец>’] unique О — возвращает массив уникальных значений
в указанном столбце.
Выберем из DataFrame уникальные значения в столбце Company.
Листинг 6.44: Фильтрация по уникальным значениям с помощью метода
unique О
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: [’А’, ’В’, ’C’, ’A’, ’B’J,
’Price’: [100, 200, 300, 100, 200]
}
df = pd,DataFrame(data)
# Получаем уникальные значения в столбце Company
unique-values = df[’Company’].unique()
print(unique_values)
# Вывод:
# [’А’ ’В’ ’C’]
6.5.4. Фильтрация по пропущенным значениям
Фильтрация но пропущенным значениям позволяет выбирать строки
и столбцы в DataFrame на основе наличия или отсутствия пропущенных значе-
ний (NaN). Для фильтрации по пропущенным значениям используются методы
isnaO и notnaO, которые возвращают булев массив, указывающий па наличие
или отсутствие пропущенных значений в DataFrame. Синтаксис метода isnaO
выглядит следующим образом:
Листинг 6.45: Синтаксис метода isna()
1 df.isna ()
где
• df .isnaO возвращает булев массив, где True указывает на пропущен-
ные значения (NaN), a False — па непустые значения.
Выберем из DataFrame строки, где в столбце Price есть пропущенные
значения.
Листинг 6.46: Фильтрация по пропущенным значениям с помощью метода
isnaO
—
1 # Подключаем библиотеку pandas
2 import pandas as pd
3
4 # Создаем DataFrame
s data = {
« ’Company’: [’А’, ’В’, ’C’, ’A’, ’B’J,
7 ’Price’: [100, 200, None, 100, None]
s }
э df = pd.DataFrame(data)
io # Фильтруем строки, где в столбце Price есть пропущен
—? иные значения
и filtered = dfLdf[’Price’].isna ()J
12
13
14
15
16
print(filtered)
# Вывод:
# Company Price
# 2 C NaN
# 4 В NaN
В данном примере мы создаем DataFrame с двумя столбцами: Company и Price,
где в столбце Price есть пропущенные значения (NaN). Затем мы используем
метод isna() для фильтрации строк, где в столбце Price есть пропущенные
значения. При этом мы используем булев массив df [ * Price ’1 isna (), который
возвращает логическое условие для фильтрации строк
Для фильтрации по непустым значениям используется метод notnaO,
который возвращает булев массив, указывающий на наличие непустых значений
в DataFrame Синтаксис метода notnaO выглядит следующим образом:
Листинг 6.47: Синтаксис метода notnaO
df.notna О
где
• df .notnaO возвращает булев массив, где True указывает па непустые
значения, a False — на пропущенные значения (NaN).
Выберем из DataFrame строки, где в столбце Price нет пропущенных значений.
Листинг 6.48: Фильтрация по непустым значениям с помощью метода notnaO
1 # Подключаем библиотеку pandas
2 import pandas as pd
4 n Создаем DataFrame
s data = {
6 ’Company’- [’А’, ’В’, ’С’, ’A’, ’B’],
7 ’Price’ [100, 200, None, 100, None]
s }
э df = pd DataFrame(data)
10 # Фильтруем строки, где в столбце Price нет пропущена—*
> ных значений
n filtered = df[df[’Price’].n^tna()]
12 print (filtered)
13 # Зивод:
14 # Company Price
15 # 0 А 100.0
16 # 1 В 200.0
17 # 3 А 100.0
В приведенном примере мы создаем DataFrame с двумя столбцами:
Company и Price, где в столбце Price есть пропущенные значения (NaN).
Затем мы используем метод notnaO для фильтрации строк, где в столб-
це Price нет пропущенных значений. При этом мы используем булев массив
df [’Price’] .notnaO, который возвращает логическое условие для фильтра-
ции строк.
§ 6.6. Группировка и агрегация данных
Группировка и агрегация данных в pandas позволяют выполнять опера-
ции над подмножествами данных, что полезно для анализа и обработки боль-
ших объемов информации. Группировка данных позволяет объединять строки
по определенным критериям, а агрегация позволяет выполнять вычисления над
сгруппированными данными, такие как сумма, среднее, максимум и минимум.
Для группировки данных в pandas используется метод groupby О, который поз-
воляет группировать данные по одному или нескольким столбцам. Синтаксис
метода groupby () выглядит следующим образом:
Листинг 6.49: Синтаксис метода groupby ()
1 df.groupby(by = [’<столбец!>’, ’ <столбец2>’])
где
• by — список столбцов, по которым выполняется группировка;
• df.2гоирЬу(Ьу=[’<столбец1>’, ’<столбец2>’]) возвращает объект
DataFrameGroupBy. который представляет собой сгруппированные данные.
Выберем из DataFrame сгруппированные данные ио столбцу Company
и посчитаем сумму цеп для каждой компании.
Листинг 6.50: Группировка данных с помощью метода groupbyO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: [’А’, ’В’, ’C’, ’A’, ’B’J,
’Price’: [100, 200, 300, 100, 200]
df = pd.DataFrame(data)
# Группируем данные по столбцу Company и считаем сум<—»
«-> му цен для каждой компании
grouped = df.groupby(by-[’Company’]).sum()
print(grouped)
а Вывод:
я Price
п Company
# А 200
# В 400
С 300
В данном примере мы создаем DataFrame с двумя столбцами Company
и Price. Затем мы используем метод groupbyO для группировки данных по
столбцу Company и вычисления суммы цеп для каждой компании.
Для агрегации данных после группировки используется метод aggO,
который позволяет выполнясь различные вычисления над сгруппированными
данными Синтаксис метода agg() выглядит следующим образом:
Листинг 6.51: Синтаксис метода aggO
1 df .groupby(by=[’<столбец1>’ , ’«столбец*-1 * * * *
е—> 2>’]).agg({’<столбецЗ>’: ’<агрегатная функция?»’, <—>
с—> ’ <столбец4>’: ’<агрегатная функция>’})
где
• by - список столбцов, по которым выполняется группировка;
• agg() метод, который позволяет выполнять агрегацию данных;
• <столбецЗ>, <стол6ец4> — имена столбцов, для которых выполняется аг-
регация;
• <агрегатная функция> - функция агрегации, которая может быть одной
из следующих: ’sum’, ’mean’, ’max’, ’min’, ’count’ и другие.
Выберем из DataFrame сгруппированные данные по столбцу Company
и посчитаем сумму и среднее значение цен для каждой компании
Листинг 6.52: Агрегация данных с помощью метода aggO
1
2
3
4
5
б
7
S
9
10
11
12
13
# Подключаем библиотеку рапааз
import pandas as pd
# Создаем DataFrame
data = {
’Company’" [’А’, ’В’, ’C’, ’A’, ’B’J,
’Price’: [100, 200, 300, 100, 200]
}
df = pd.DataFrame(data)
# Группируем данные по столбцу Company и считаем суме^
<—> му и среднее значение цен для каждой компании
grouped = df.groupby(by=[’Company’]) agg({’Price’: «—1
[’sum’, ’mean’]})
print(grouped)
# Вывод:
14 # Price
15 # sum mean
16 # Company
17 # А 200 100 0
18 # В 400 200.0
19 # С 300 300.0
В данном примере мы создаем DataFrame с двумя столбцами: Company
п Price Затем мы используем метод groupby() для группировки данных по
столбцу Company и вычисления суммы и среднего значения цен для каждой
компании. При этом мы передаем в метод agg() словарь, где ключами являются
имена столбцов, доя которых выполняется агрегация, а значениями — список
агрегатных функций, которые нужно применить к этим столбцам.
§ 6.7. Объединение таблиц
Объединение таблиц в pandas позволяет соединять данные из разных
источников, что полезно для анализа и обработки больших объемов информа-
ции. Для объединения таблиц в pandas используются методы mergeO, joanO
и concatO
Метол mergeO позволяет объединять два DataFrame по одному или
нескольким столбцам, которые служат ключами для объединения. Синтаксис
метода mergeO выглядит следующим образом:
Листинг 6.53: Синтаксис метода merge О
1 df 1 . merge (df 2 , how= ’ inner ’ , on= [ ’ <ключ 1 > ’ , ’<.ключ2>’])
где
• df 1 первый DataFrame, который нужно объединить;
• df2 второй DataFrame, который нужно объединить;
• how — способ объединения, может принимать значения: ’inner’ (внутрен-
нее соединение), ’outer’ (внешнее соединение), ’left’ (левое соединение)
и ’right’ (правое соединение);
• on — список столбцов, ио которым выполняется объединение.
• dfl.merge(df2, how=’inner’, оп=[’<ключ1>’, ’<ключ2>’]) возвра-
щает новый DataFrame. содержащий объединенные данные.
Выберем из двух DataFrame данные, объединенные по столбцу Company, с ис-
пользованием внутреннего соединения.
Листинг 6.54: Объединение таблиц с помощью метода merge О
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Подключаем библиотеку pandas
import pandas as pd
# Создаем первый DataFrame
datal = {
’Company’: [’A’, ’B’, ’C’J,
’Price’: [100, 200, 300]
}
dfl = pd.DataFrame(datal)
# Создаем второй DataFrame
data2 = (
’Company’. [’A’, ’B’, ’D’],
’Quantity’: [10, 20, 30]
}
df2 = pd.DataFrame(data2)
# Объединяем DataFrame nr- столбцу Company с использоР
ванием внутреннего соединения
merged = df1.merge(df2, how=’inner’, on-’Company’)
print(merged)
Вывод:
Company Price Quantity
# 0 А 100 10
1 В 200 20
В данном примере мы создаем два DataFrame: первый содержит инфор-
мацию о компаниях и ценах, а второй информацию о компаниях и количестве
товаров. Затем мы используем метод merge () для объединения этих DataFrame
по столбцу Company с использованием внутреннего соединения. При этом мы
указываем параметр how=’inner’, чтобы выполнить внутреннее соединение,
и параметр on=’Company’, чтобы указать столбец, по которому выполняется
объединение. Для объединения по нескольким столбцам можно передать спи-
сок столбцов в параметр on Например, если нужно объединить по столбцам
Company и Price, то синтаксис будет выглядеть так:
Листинг 6.55: Объединение по нескольким столбцам с помощью метода merge ()
/--------------------------------------------------------------\
1 merged = df1.merge(df2, how=’inner’, on-[’Company’ , <—‘
w ’Price ’ ])
Метод join() позволяет объединять два DataFrame по индексам, что полезно,
когда нужно соединить данные по строкам. Синтаксис метода join О выглядит
следующим образом:
Листинг 6.56: Синтаксис метода join О
1 df 1 . j oin (df 2 , how=’inner’, lsuffix= ’ _left ’ , <-»
—/ rsuffix=’.right ’ )
где
• df 1 — первый DataFrame, который нужно объединить:
• df2 второй DataFrame, который нужно объединить:
• how способ объединения, может принимать значения: ’inner’ (внутрен-
нее соединение), ’outer’ (внешнеесоединение), ’left’ (левоесоединение)
и ’right’ (правое соединение);
• Isuffix — суффикс, добавляемый к столбцам первого DataFrame, если
есть дублирующиеся имена столбцов;
• rsuffix суффикс, добавляемый к столбцам второго DataFrame. если
есть дублирующиеся имена столбцов.
• df1.join(df2, how=’inner’, Isuffix=’_left’, rsuffix=’_right’)
возвращает новый DataFrame, содержащий объединенные данные.
Выберем из двух DataFrame данные, объединенные по индексам, с ис-
пользованием внутреннего соединения.
Листинг 6.57: Объединение таблиц с помощью метода join О
1
2
3
4
5
в
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Подключаем библиотеку pandas
import pandas as pd
# Создаем первый DataFrame
daral = {
’Price ’ : [100, 200, 300] ,
’Quantity’: [10, 20, 30]
}
df1 = pd.DataFrame(data 1, index=[’A’, ’В’, ’C’])
# Создаем второй DataFrame
data2 = {
’ Price ’ : [150 , 250 , 350] ,
'Quantity’: [15, 25, 35]
df2 = pd DataFrame(data2, index“[’A’, ’B’, ’D’])
# Объединяем DataFrame по индексам с использованием e->
внутреннего соединения
merged = df 1 . join (df2 , how=’inner ’ , e-5
«-> 1 suf f ix= ’ _lef t ’ , rsuffix=’_right’)
print (merged) # ы o,_
# Price_left Quantity_left Price_right «—>
w Quantity^rigbt
# A 100 10 150
-> 15
# В 200 20 250 <->
-> 25
В примере мы создаем два DataFrame первый содержит информацию
о ценах и количестве товаров для компаний А. В и С, а второй информацию
о ценах и количестве товаров для компаний А, В и D. Затем мы используем
метод joint) для объединения этих DataFrame по индексам с использовани-
ем внутреннего соединения. При этом мы указываем параметр how= ’ inner ’,
чтобы выполнить внутреннее соединение, и суффиксы lsuffix=’_left’
и rsuffix=’.right’, чтобы избежать конфликтов имен столбцов.
Для объединения по индексам можно использовать метод joint) без ука-
зания параметра how. если нужно выполнить внутреннее соединение по умолча-
нию. Например, если нужно объедини ть по индексам без указания суффиксов,
то синтаксис будет выглядеть так:
Листинг 6.58: Объединение по индексам с помощью метода joint) без суффик-
сов
1 merged = df1 - joinCdf2)
Метод concatt) позволяет объединять несколько DataFrame по строкам
пли столбцам, что полезно, когда нужно объединить данные из нескольких ис-
точников в один DataFrame. Синтаксис метода concatt) выглядит следующим
образом:
Листинг 6.59: Синтаксис метода concatt)
1 pd concatttdfl, df2] , axis=0, ignore_index = False, <—’
<—> join= ’ outer ’ )
ГДС
• [dfl, df 2] — список объединяемых DataFrame;
• axis=0 объединение по строкам (по умолчанию);
• ignore_index=False сохранение исходных индексов (по умолчанию);
• join=’outer’ объединение по всем индексам (по умолчанию).
Выберем из двух DataFrame данные, объединенные ио строкам.
Листинг 6.60: Объединение таблиц с помощью метода concatO
i
2
3
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Подключаем библиотеку pandas
import pandas as pd
# Создаем первый DataFrame
datal = {
’Company’: [’А’, ’В’, ’C’],
’Price’: [100, 200, 300]
}
dfl = pd.DataFrame(datal)
# Создаем второй DataFrame
data2 = {
’Company’; [’D’, ’E’, ’F’],
’Price’: [400, 500, 600]
}
df2 = pd.DataFrame(data2)
# Объединяем DataFrame по строкам
merged = pd.concat ([df1 , df2], axis=0,
ignore_index=True)
print(merged)
# Вывод:
# Company Price
# 0 A 100
# 1 В 200
it 2 C 300
# 3 D 400
it 4 E 500
it 5 F 600
В данном примере мы создаем два DataFrame: первый содержит инфор-
мацию о компаниях и ценах, а второй информацию о других компаниях
и ценах. Затем мы используем метод concatO для объединения этих DataFrame
ио строкам. При этом мы указываем параметр axis-О, чтобы выполнить обь-
единение по строкам, и параметр ignore.index=True, чтобы иереиндексировать
объединенный DataFrame. Для объединения по столбцам можно использовать
параметр axis=l. Например, если нужно объединить по столбцам, то синтаксис
будет выглядеть так:
Листинг 6.61: Объединение по столбцам с помощью метода concatO
1 merged = pd.concat([df1, df2], »xis=l, H
ignore_index = False)
Метод concatO также позволяет использовать параметр join, чтобы
указать способ объединения по индексам. Например, если нужно выполнить
внешнее соединение по индексам, то синтаксис будет выглядеть так:
Листинг 6.62: Объединение с внешним соединением с помощью метода concat ()
1 merged = pd.concat ([dfl , df2] , axis=0,
«-+ ignore.index-True , join = ’ outer ’)
§ 6.8. Сводные таблицы
Сводные таблицы в pandas позволяют агрегировать и обобщать данные,
что полезно для анализа и представления информации в удобном виде. Свод-
ные таблицы позволяют группировать данные по одному или нескольким столб-
цам и выполнять агрегацию значений в других столбцах. Для создания сводной
таблицы в pandas используется метод pivot.table(), который позволяет созда-
вать сводные таблицы на основе DataFrame. Синтаксис метода pi vor_table()
выглядит следующим образом:
Листинг 6.63: Синтаксис метода pivot_table()
—
1 pd.pivot_table(df, va]ues=’<значения>’ , 4—
> index= [ ’ ^индекс 1 > ’ ,
a ’ <индекс2> ’ ] , <—’
> columns=[’<столбец1>’,
з ’ <столбец2> ’ 1 , +->
aggfunc=’<агрегатная функциях
4 fill_value=None)
где
• df исходный DataFrame, на основе которого создается сводная таблица;
• values — столбец, значения которого будут агрегироваться;
• index список столбцов, по которым выполняется группировка (индексы
сводной таблицы);
• columns список столбцов, которые будут использоваться в качестве
столбцов сводной таблицы:
• aggfunc функция агрегации, которая будет применяться к значениям
(например, ’sum’, ’mean’, ’count’ и т.д.);
• f lll_value значение, которым будут заполнены пропущенные значения
в сводной таблице (по умолчанию None);
• pd.pivot_table(df, уа!иез=’<значения>’, 1пЬех=[’<индекс1>’,
’<индекс2>’], со1итпз=[’<столбец1>’, ’<столбец2>,
aggfunc=’<arperaTHaa функция>’, fill_value=None) возвращает но-
вый DataFrame. представляющий сводную таблицу.
Выберем из DataFrame сводную таблицу, которая агрегирует данные по
столбцу Company и считает сумму цен для каждой компании
Листинг 6.64: Создание сводной таблицы с помощью метода pivot_table()
i
2
3
4
6
7
8
9
10
11
12
13
14
15
16
17
18
# Подключаем библиотеку pandas
import pandas as pd
# Создаем DataFrame
data = {
’Company’: [’А’, ’В’, ’A’, ’B’, ’A’],
’Product’: [’Pl’, ’ P2 ’ , ’P3’, ’ P4 ’ , ’P5 ’ ] ,
’Price’: [100, 200, 150, 250, 300]
}
df = pd.DataFrame(data)
# Создаем сводную таблицу
pivot_table = pd.pivot.table(df , values=’Price’,
'-+ index=[’Company’], aggfunc=’sum’)
print(pivot_table)
# Вывод:
# Price
# Company
# A 550
# В 450
В данном примере мы создаем DataFrame с тремя столбцами Company,
Product и Price Затем мы используем метод pivot .table О для создания свод-
ной таблицы, которая агрегирует данные по столбцу Company и считает сумму
цен для каждой компании. При этом мы указываем параметр values=’Pr ice’,
чтобы агрегировать значения по столбцу' Price Параметр index=[’Company’]
указывает, что сводная таблица будет группироваться но столбцу Company,
а параметр aggfunc=’sum’ указывает, что нужно использовать функцию суммы
для агрегации значений.
Если нужно создать сводную таблицу с несколькими индексами, то мож-
но передать список столбцов в параметр index. Например, если нужно создать
сводную таблицу с индексами Company и Product, то синтаксис будет выглядеть
так:
Листинг 6.65: Создание сводной таблицы с несколькими индексами
—
1 pivot_table = pd.pivot_table(df , values= ’Price ’ , н
> index=[’Company ’ , ’Product’], aggfunc=’sum’)
Если нужно создать сводную таблицу с несколькими столбцами, то мож-
но передать список столбцов в параметр columns Например, если нужно со-
здать сводную таблицу с столбцами Company и Product, то синтаксис будет
выглядеть так:
Листинг 6.66: Создание сводной таблицы с несколькими столбцами
1 pivot_table = pd.pivot_table(df, values = ’Price’, <—>
«-> index=[’Company’], coltimns = [’ Product ’] , w
> aggfunc=’sum’)
Если нужно заполнить пропущенные значения в сводной таблице, то
можно использовать параметр f ill_value Например, если нужно заполнить
пропущенные значения нулями, то синтаксис будет выглядеть так:
Листинг 6.67: Заполнение пропущенных значений в сводной таблице
pivot.table = pd pivot_table ( df , values = ’ Price ’ , <->
index= [’ Company ’] , aggf unc= ’ sum ’ , fill_value=O)
Контрольные вопросы
В этом разделе представлены контрольные вопросы по работе с библио-
текой pandas. Ответы на эти вопросы помогут закрепить знания и навыки, по-
лученные в ходе изучения библиотеки.
1. Что такое объект Series в pandas и чем он отличается от обычного списка
Python?
2. Как создать Series из словаря? Приведите пример.
3. Что такое DataFrame и как он соотносится с Series?
4. Приведите три способа создать DataFrame.
5. В каких случаях имеет смысл использовать Series, а нс DataFrame?
6. Как загрузить данные из файла CSV в pandas? Какие параметры можно
использовать при загрузке?
7. Как сохранить объект DataFrame в файл Excel? Какие параметры можно
использовать при сохранении?
8. В чем разница между методами read_csv и read_excel?
9. Как выбрать один столбец DataFrame по его имени? Приведите пример.
10. Как выбрать несколько столбцов DataFrame по их именам? Приведите
пример.
11. Как выбрать несколько строк DataFrame по их индексам? Приведите при-
мер.
12. Опишите, как фильтровать строки DataFrame по сложному логическому
условию с несколькими выражениями.
13. Как отсортировать DataFrame но одному или нескольким столбцам? При-
ведите пример.
14. Как изменить порядок столбцов в DataFrame? Приведите пример.
15. Как добавить новый столбец в DataFrame? Приведите пример.
16. Как удалить столбец из DataFrame? Приведите пример.
17. Как переименовать столбцы в DataFrame? Приведите пример.
18. Как получить статистическую информацию о числовых столбцах
DataFrame? Какие методы для этого существую!?
19. Как получить информацию о типах данных в столбцах DataFrame? Какие
методы для этого существуют?
20. Как получить количество строк и столбцов в DataFrame? Какие методы
для этого существуют?
21. Как получить доступ к строкам и столбцам DataFrame по меткам и пози-
циям? Какие методы для этого существуют?
22. Как получить доступ к единственному элементу DataFrame по метке
п позиции? Приведите пример.
23. Как получить доступ к строкам и столбцам DataFrame с помощью логи-
ческой индексации? Приведите пример.
24. Как получить доступ к строкам и столбцам DataFrame с помощью метода
1ос? Приведите пример.
25. Как одновременно извлечь несколько столбцов и получить новый
DataFrame? Приведите пример.
26. Как проверить наличие пропущенных значений в объекте DataFrame или
Series?
27. Как получить уникальные значения в столбце объекта DataFrame? Какие
методы для этого существуют?
28. Как посчитать количество уникальных значений в столбце объекта
DataFrame? Какие методы для этого существуют?
29. Как заполнить пропуски в категориальном столбце наиболее частым зна-
чением этого столбца?
30. Как заполнить пропуски в числовом столбце средним значением этого
столбца?
31. Как удалить строки с пропущенными значениями в DataFrame? Приведите
пример.
32. Как посчитать количество пропущенных значений в каждом столбце
DataFrame?
33. Что делает метод groupby и как с его помощью получить среднее значение
в каждой группе?
34. Как использовать метод agg для применения нескольких агрегатных
функций к сгруппированным данным? Приведите пример.
35. Как объединить два объекта DataFrame но общему столбцу? Какие методы
для этого существуют?
36. Как объединить два объекта DataFrame ио индексам? Какие методы для
этого существуют?
37. Как объединить два объекта DataFrame по индексам и столбцам? Какие
методы для этого существуют?
38. Как объединить два объекта DataFrame по индексам и столбцам с исполь-
зованием внешнего соединения? Какие методы для этого существуют?
39. Как объединить два объекта DataFrame по индексам и столбцам с исполь-
зованием внутреннего соединения? Какие методы для этого существуют?
40. Как объединить два объекта DataFrame по индексам и столбцам с исполь-
зованием левого соединения? Какие методы для этого существуют?
41. Как объединить два объекта DataFrame по индексам и столбцам с исполь-
зованием правого соединения? Какие методы для этого существуют?
42. Как объединить два объекта DataFrame по индексам и столбцам с исполь-
зованием перекрестного соединения? Какие методы для этого существу-
ют?
43. Что такое сводные таблицы в pandas и как их создать? Какие параметры
можно использовать при создании сводной таблицы?
44. Как создать сводную таблицу, в которой строки это значения одного
столбца, а столбцы — значения другого?
45. Какие параметры pivot_table позволяют одновременно указать несколь-
ко ад регатных функций?
Практикум: работа с основными структурами pandas
Упражнения
1. Создайте объект Series из списка целых чисел от 1 до 15 и выведите его
на экран. Дополнительно выведите атрибуты dtype. shape и index.
2. Создайте объект Series из списка названий животных Г’слон’, ’тигр’,
’лев’, ’жираф', ’зебра’, ’кенгуру’] и выведите его па экран с поль-
зовательским индексом от ’А’ до ’F’.
3. На основе словаря с оценками студентов создайте Series, где индекс
имя студента, значение его балл:
student_grades = •{
’Анна’: 92,
’ Борис ’ : 78,
’Виктория’: 85,
’Г ригорий’: 91,
’Дарья’: 73,
’Евгений’: 88
}
Выведите созданный объект и его основные атрибуты.
4. Создайте объекты Series и DataFrame па основе словарей содержащих
следующий данные:
а) название 10 стран Азии, их столипы и численность населения каждой
страны:
б) название 10 стран Европы, их столицы и численность населения каж-
дой страны;
в) название 10 стран Африки, их столипы и численность населения каж-
дой страны;
г) название 10 стран Южной Америки, их столицы и численность насе-
ления каждой страны.
5. Создайте DataFrame из следующего словаря и выведите его, а также ин-
формацию о типах данных (dtypes):
employees_data = {
’Имя’: [’Алексей’ , ’Мария’, ’Петр’, ’Елена’, ’Мва*-»
н ’ , ’ Ольга ’ ] ,
’Город’: [’Москва’, ’Санкт-Петербург’, ’Казань’, ’
«-> ’ Омск ’ ,
’Екатеринбург’, ’Нижний Новгород’],
’Возраст’: [28, 34, 45, 29, 52, 31],
’Зарплата’: [75000, 85000, 95000, 70000, 120000, <-
W 78000]
}
а) Используя методы head (4) и tail (3). выведите первые 4 и последние
3 строки DataFrame.
б) Выберите столбец 'Возраст' тремя разными способами (как атрибут,
через квадратные скобки, через метод) и выведите результат.
в) Выберите одновременно столбцы Имя’, ‘Город’ и ’Зарплата’, создав
новый DataFrame.
г) Используя 1ос[]. выберите из DataFrame вторую, третью и четвер-
тую строки и первые два столбца.
д) Отфильтруйте DataFrame так, чтобы остались только сотрудники
старше 30 лет с зарплатой выше 80000.
е) Выберите сотрудников, которые работают в Москве ИЛИ Санкт-
Петербурге И имеют возраст от 25 до 40 лет включительно.
ж) Отсортируйте DataFrame по столбцу 'Зарплата' в порядке убывания.
з) С помощью sample(n=3, random_state=42) выберите 3 случайные
строки из DataFrame
и) Добавьте новые столбцы:
• Тод_рождения’ 2024 - Возраст
• ’Налог* — Зарплата х 0.13
• ’Зарплата после налога’ Зарплата - Налог
к) Переименуйте столбцы: ’Город' —> ’Местоположение’, ’Возраст’ —>
’Лет', ’Зарплата’ —> ’Оклад’. Используйте метод rename().
л) Добавьте новую строку с данными о новом сотруднике:
new^employee = {
’Имя’: ’Сергей ’ ,
’Местоположение’: ’Казань’,
’Лет’: 30,
’Оклад’: 80000
м) Используя groupbyO, сгруппируйте сотрудников по городам и вы-
числите среднюю зарплату и средний возраст для каждого города.
н) К сгруппированным данным примените агрегацию:
• agg <<
’Возраст’: [’min’, ’max’, ’mean’, ’count’],
’Зарплата’: [’min’, ’max’, ’mean’, ’sum’]
})
и) Подсчитайте количество уникальных городов в DataFrame с помощью
nuniqueO Дополнительно выведите список уникальных городов ме-
тодом unique().
п) Сохраните итоговый DataFrame задачи в трех форматах:
• CSV (employees.!inal.csv)
• Excel(employees.!inal.xlsx)
• Parquet (employees.!inal.parquet)
6. Создайте CSV-файл с данными о сотрудниках (минимум 8 записей)
с колонками id,name,department,salary,experience.years. Загрузите
его в DataFrame, выведите первые 5 строк и вызовите методы 1п!о()
и describe().
7. Сохраните DataFrame из предыдущего задания в Excel-файл
company.employees .xlsx без включения индекса и с названием листа «Со-
трудники».
8. Создайте DataFrame с временными данными, используя даты в качестве
индекса:
finane1 al.data = {
’Дата’: [’2024-01-15’, ’2024-02-15’, ’2024-03-15’,
’2024-04-15’, ’2024-05-15’],
’Выручка’: [450000. 520000, 380000, 610000,
w 480000] ,
’Расходы’: [320000, 380000, 290000, 420000,
> 350000] ,
’Прибыль’. [130000, 140000, 90000, 190000, 130000]
}
а) Выведите информацию о DataFrame с помощью метода info().
б) Выведите статистику по числовым столбцам с помощью метода
describeC).
в) Преобразуйте столбец ’Дата' в datetime-формат и установите его как
индекс.
г) Используя 1ос[]. извлеките данные за дату ’2024-03-15' по всем
столбцам.
д) Выберите данные за период с ’2024-02-01’ но ’2021-04-30' и выведите
их.
е) Добавьте новый столбец ’Рентабельность’, рассчитанный как Прибыль
/ Выручка * 100.
ж) Создайте копию DataFrame и намеренно добавьте несколько значений
NaN. Затем удалите строки с пропущенными значениями с помощью
dropnaO.
9. Создайте два DataFrame:
departments = pd.DataFrame({
’dept.id’: [1, 2, 3, 4],
’dept_name’: [’IT’, ’HR’, ’Финансы’, ’Маркетинг’],
’manage: [’Иванов’, ’Петрова’, ’Сидоров’, ’Козлове^
е > а ’ ]
})
employees = pd DataFrame({
’emp.id’: [101, 102, 103, 104, 105],
’name’: [’Алексей’, ’Мария’, ’Петр’, ’Елена’, ’Дме^
> итрий ’ ] ,
’dept_jd’; [1, 2, 1, 3, 5]
})
Объедините их по dept_id используя inner, left, right и outer join.
Проанализируйте различия в результатах.
10. Создайте два дополнительных DataFrame с информацией о сотрудниках
за разные периоды и объедините их вертикально с помощью pd. concatO
Сбросьте индекс методом reset_index(drop=True).
11. Создайте сводную таблицу из DataFrame задачи 8:
pivot_table(index=’Дата’, values = [’Выручка ’ , ’Расходы*-1
aggfunc=’sum’)
12. Создайте более сложную сводную таблицу, добавив столбец ‘Квартал’
в DataFrame задачи 8 и создав сводную таблицу по кварталам и месяцам.
13. Создайте. DataFrame с данными о продажах по регионам и продуктам:
sales_data = {
’Регион’; [’Москва’, ’СПб’, ’Москва’, ’Казань’,
<-> СПб ’ ,
’Москва’, ’Казань’, ’СПб’],
’Продукт’: [’А’, ’А’, ’В’, ’А’, ’В’, ’А’, ’В’, ’
А’] ,
’Продажи’: [100, 150, 200, 80, 120, 110, 90, 140],
’Количество’: [10, 15, 12, 8, 9, 11, 7, 14]
}
Выполните следующие операции:
• создайте сводную таблицу по регионам и продуктам:
• найдите топ-3 комбинации регион-продукт по продажам;
• вычислите долю каждого региона в общих продажах:
• создайте столбец со средней ценой за единицу товара.
Заключение
В этом разделе мы рассмотрели основные возможности библиотеки
pandas для работы с данными в формате Series и DataFrame Мы изучили, как
создавать эти объекты и манипулировать ими. а также как выполнять опера-
ции фильтрации, агрегации и объединения данных. Библиотека pandas предо-
ставляет мощные инструменты для анализа и обработки данных, что делает
се незаменимым инструментом для работы с данными в Python. Мы рассмот-
рели основные методы и функции, которые позволяют эффективно работать
с данными, а также изучили, как использовать сводные таблицы для агрега-
ции и обобщения данных. Библиотека pandas является основным инструментом
для анализа данных в Python и широко используется в научных и коммерче-
ских приложениях. В заключение важно отметить, что pandas предоставляет
множество возможностей для работы с данными и изучение этой библиотеки
является важным шагом для любого специалиста, работающего с данными.
Список литературы
1. NumPy Developers. NumPy Documentation. 2025. — URL: https: //numpy.
org/doc/stable/ (дата обращения: 01.02.2025).
2. Pandas Development Team. Pandas Documentation. — 2025. — URL: https:
//pandas.pydata.org/docs/ (дата обращения: 01.02.2025).
3. Project Jupyter. Project Jupyter Documentation. — 2025. — URL: https :
//docs.jupyter.org/ (дата обращения: 01.02.2025).
4. Python Software Foundation. Index of Python Enhancement Proposals
(PEPs). — 2025. — URL: https://peps python org/ (дата обращения:
01.02.2025).
5. Python Software Foundation. Python Documentation. — 2025. — URL: https:
//docs.python org/З/ (дата обращения: 01.02.2025).
6. Python Software Foundation. The Python Standard Library. 2025. URL:
https //docs python.org/3/library/ (дата обращения: 01.02.2025).
7. Rossum G. van, 14arsaw B., Coghlan N. PEP 8 Style Guide for Python
Code. 2001. URL: https : //peps . python . org/pep- 0008/ (дата обра-
щения: 01.02.2025).
8. Берман К. Основы Python для Data Science. Санкт-Петербург : Питер,
2023. С. 272.
9. Васильев Л. Н. Программирование на Python в примерах и задачах.
Москва : Эксмо, 2021. С. 616.
10. Гарафутдинов Р. В. Python для анализа данных : учебное пособие.
Пермь : Пермский государственный национальный исследовательский
университет, 2024. — С. 276.
11. Маккинни У. Python и анализ данных. — 3-е изд. — Москва : ДМК Пресс,
2023. С. 536.
12. Пасхавер Б. Pandas в действии. — Санкт-Петербург : Питер. 2025. — С. 512.
13. Плас Д. В. Python для сложных задач. Наука о данных и машинное обу-
чение. — Санкт-Петербург : Питер, 2022. — С. 576.
14. Саммерфильд М. Программирование на Python 3. Подробное руковод-
ство. — Москва : Символ-Плюс, 2009. — С. 608.
15. Сысоева М В., Сысоев И. В. Программирование для «нормальных» с нуля
на языке Python: учебник: в двух частях под рсд. В. Л. Черного.
2-е изд., испр. и доп. — Москва : Базальт СПО ; МАКС Пресс, 2023.
С. 184+184. — (Библиотека ALT).
Гутник Сергей Александрович. Лата Александр Николаевич
ВЫЧИСЛИТЕЛЬНЫЕ МЕТОДЫ НА PYTHON
Учебное пособие
13 двух книг ах
Книга вторая (главы 5 6)
Шеф-редактор И. Ю. Окунев
Заведующая редакцией Л. С. Жирнова
Выпускающий редактор Н. Г. Карпинская
Компьютерная верстка А. И. Лата
Художественное оформление обложки А. Г. Киров
Допечатал подготовка А. О. Бирюков
Подписано в печать 23.12.2U25. Формат 60 х 84 >/ч.
Усл. печ. л. 22.8 Уч.-изд. л. 6 Заказ К* 14912
Издательский дом МГИМО
119454, Москва, пр. Вернадского, 76
mgimo.ru/id; id@inno.mgimo.ru
Отпечатано в производственном отделе
Издательского дома МГИМО
119454. Москва, пр. Вернадского, 76
nigimo.ru/id; printOinno.mgimo.ru
МГИМО
ИЗДАТЕЛЬСКИЙ
ДОМ
мчс? выпускает учебные издания по Kiswahili
AM X АРСКИЙ English -2 СУАХИЛ И Точней
АНГЛИЙСКИЙ АРАБСКИЙ иностранным языкам: ТАДЖИКСКИЙ Turkle ТУРЕЦКИЙ
Afrikaans Bahasa Indonesu Nederlands Украшська
АФРИКААНС ИНДОНЕЗИЙСКИЙ НИДЕРЛАНДСКИЙ УКРАИНСКИЙ
Espanol Norsk
БЕНГАЛЬСКИЙ ИСПАНСКИЙ НОРВЕЖСКИЙ УРДУ
Български Italiano (^9 Is Suomi
БОЛГАРСКИЙ Tieng Viet ИТАЛЬЯНСКИЙ г., > . ПЕРСИДСКИЙ Polski ФИНСКИЙ
Ч1 X Fran^ais
вьетнамский КИТАЙСКИЙ ПОЛЬСКИЙ ФРАНЦУЗСКИЙ Гл П
ГПТМ<|\г\[\ Portugues 11?’ч!
готский КОРЕЙСКИЙ ПОРТУГАЛЬСКИЙ ХИНДИ
Ел/оулхя Hrvatski
ГРЕЧЕСКИЙ ЛАОССКИЙ ПУШТУ ХОРВАТСКИЙ
Latina Romana Cestina
ДАРИ ЛАТИНСКИЙ РУМЫНСКИЙ ЧЕШСКИЙ
Dansk Монгол Русский Svenska
ДАТСКИЙ монгольский РУССКИЙ ШВЕДСКИЙ
Deutsch Српски
ИВРИТ НЕМЕЦКИЙ СЕРБСКИЙ ЯПОНСКИЙ
mgimo.ru/id
МГИМО
ИЗДАТЕЛЬСКИЙ
ДОМ
18 2^
Гутник
Сергей Александрович
доцент кафедры
математики,
эконометрики
и информационных
технологий, доктор
физико-математических
наук, доцент
Лата
Александр Николаевич
преподаватель кафедры
математики, эконометрики
и информационных
технологий, кандидат
физико-математических
наук
xsbn я?8-5-чагв-эа?5-1
9 785922 830751
ийММи
^раЭиЦми Тип,
МГИМО
ИЗДАТЕЛЬСКИЙ
ДОМ
е?и
* ,4Hhoui30B
УЧЕБНАЯ И НАУЧНАЯ
ЛИТЕРАТУРА
ПО ТЕМАМ
международные
отношения
mgimo.ru/id
страны и регионы
мира
•
мировая
экономика
vk.com/mgimoid
международное
право
иностранные
языки
books@inno.mgimo ru