ЛЕКЦІЯ 1

NumPy
• Пакет NumPy(Numeric Python) використовується в аналізі даних,
машинному навчанні та наукових обчисленнях, а також значно
полегшує обробку векторів і матриць.
• Він забезпечує функціональність, яку можна порівняти з
функціональністю MatLab. NumPy надає основні методи роботи з
великими масивами та матрицями.
• Пакети SciPy, Pandas та Tensorflow використовують NumPy як
основний елемент своєї інфраструктури. По суті, це основна
цеглина аналізу даних.
Основи роботи з пакетом NumPy
Імпортування
• Якщо у вашій системі встановлено Python, ви можете встановити
NumPy за допомогою:
pip install numpy
• Щоб імпортувати NumPy та отримати доступ до його функцій,
імпортуйте його у свій код наступним чином:
import numpy as np
• Ми скорочуємо імпортоване ім'я до np для кращої читабельності коду
за допомогою NumPy. Це загальновизнана конвенція, якої потрібно
дотримуватися, щоб кожен, хто працює з нашим кодом, міг легко
зрозуміти його.
Створення масивів і матриць в NumPy
• Масив — центральна структура даних бібліотеки NumPy. Масив —
це сітка значень, яка містить інформацію про необроблені дані,
способи пошуку елемента та способи інтерпретації елемента. Всі
елементи мають однаковий тип, званий dtype-масивом.
• Найпростіший спосіб створити масив NumPy - викликати
конструктор np.array зі списком або кортежем значень:
import numpy as np
a = np.array([1, 2, 3, 4, 5], dtype=float)
print(a) # [1. 2. 3. 4. 5.]
Створення масивів і матриць в NumPy
• Також можна створити матрицю за допомогою NumPy:
m = np.array([[1, 2, 3], [4, 5, 6]], dtype=int)
print(m)
Результат:
[[1 2 3]
[4 5 6]]
• Розмірність створюваного вектора і матриці можна подивитися за допомогою атрибута
shape
import numpy as np
a = np.array([1, 2, 3, 4, 5], dtype=float)
print(a.shape) # (5,)
m = np.array([[1, 2, 3], [4, 5, 6]], dtype=int)
print(m.shape) # (2, 3)
Атрибути масивів
• shape Розміри масиву: розмір масиву вздовж кожної осі,
повертається як кортеж цілих чисел.
• ndim Кількість осей (вимірювань). Примітка: ndim ==
len(shape)
• size Загальна кількість елементів в масиві, що дорівнює
добутку елементів кортежу shape
• dtype Тип данных массива (см. ниже)
• data "Буфер" у пам'яті, який містить фактичні елементи
масиву
• itemsize Розмір в байтах кожного елемента
Створення одиничних матриць
• Для створення вектора або матриці, що складається з одиниць, використовують
метод ones
import numpy as np
a = np.ones((5,), dtype=float)
print(a)
m = np.ones((2, 3), dtype=int)
print(m)
Консольний вихід:
[1. 1. 1. 1. 1.]

[[1 1 1]
[1 1 1]]
Створення матриці, що складається з нулів
• Щоб створити вектор або матрицю, яка складається з нулів, використовують метод
zeros
import numpy as np
a = np.zeros(5, dtype=float)
print(a)
m = np.zeros((2, 3), dtype=int)
print(m)
Результат:
[0. 0. 0. 0. 0.]

[[0 0 0]
[0 0 0]]
Діагональна одинична матриця
• Щоб створити діагональну одиничну матрицю, використовують
метод identity
m = np.identity(4, dtype=int)
print(m)
Результат:
[[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]]
Створення масивів
• Для створення масиву, який містить послідовність чисел, існують два методи: np.arange и np.linspace

• Метод np.arange аналогічний методу Python range

import numpy as np
a = np.arange(5)
b = np.arange(1, 3, 0.5)
print(a)
print(b)
Результат:
[0 1 2 3 4]
[1. 1.5 2. 2.5]
Як і у випадку з діапазоном, масиви, згенеровані в цих прикладах, не включають останні елементи 5 і 3.
Створення масивів
• Щоб включити останній елемент послідовності, який ви хочете визначити, можна
використовувати метод np.linspace

import numpy as np
a = np.linspace(1, 5, num=5)
b = np.linspace(1, 3, num=3)
print(a)
print(b)
Результат:

[1. 2. 3. 4. 5.]
[1. 2. 3.]
• Як бачите, номер ключового параметра визначає кількість елементів в послідовності.
Створення масивів
• Є можливість створювати масиви і матриці, заповнені випадковими значеннями
import numpy as np
a = np.random.random(3)
b = np.random.random((3, 3))
print(a)
print(b)
Результат (при запуску прикладу цифри будуть різними, але розмірність повинна бути
однаковою):

[0.98686431 0.75971365 0.13002021]

[[0.78318837 0.18224777 0.99976367]
[0.98347105 0.67166331 0.28229379]
[0.75064336 0.97735688 0.2869088 ]]
 Індексація
• Масив NumPy можна розділити на частини і присвоїти їм індекси. Те, як він
працює, схоже на те, як він працює зі списками Python.
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a[0])
print(a[1:])
print(a[:2])
Результат:
1
[2 3 4 5]
[1 2]
 Індексація
• Індексація багатовимірного масиву NumPy дещо відрізняється від індексації звичайного списку списків в Python: замість
вказівки індексу шуканого елемента в окремих квадратних дужках m[i][j] використовується кортеж цілих чисел m[i, j]:
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
print(a[1, 1])
print(a[1:, 1])
print(a[0, :2])
Результат:
[[1 2 3]
[4 5 6]
[7 8 9]]
5
[5 8]
[1 2]
Основні типи даних (dtype) NumPy
• Повний список числових типів даних знаходиться в офіційній
документації бібліотеки NumPy.
• У таблиці нижче перераховані найбільш часто використовувані з
них. Всі ці типи існують в пакеті NumPy, тому на них можна
посилатися, наприклад, як np.uint16.
• До типів даних, які створюються за замовчуванням, коли ви
використовуєте вбудовані числові типи Python, додається
скінченний символ підкреслення: np.int_, np.float_, np.complex_
та np.bool_.
Типи даних NumPy
Тип даних Опис:
• int_ Тип цілого числа за замовчуванням, який відповідає типу long
мови C: залежить від платформи
• int8 Ціле число в 1 байті: від −128 до 127
• int16 Ціле число в 2 байтах: від −32 768 до 32 767
• int32 Ціле число в 4 байтах: −2 147 483 648 до 2 147 483 647
• int64 Ціле число в 8 байтах: від −263 до 263 -1
• uint8 Беззнакове ціле число в 1 байті: від 0 до 255
• uint16 Беззнакове ціле число в 2 байтах: від 0 до 65 535
• uint32 Беззнакове ціле число в 4 байтах: від 0 до 4 294 967 295
• uint64 Беззнакове ціле число в 8 байтах: від 0 до 264 − 1
Типи даних NumPy
• uint8 Беззнакове ціле число в 1 байті: від 0 до 255
• uint16 Беззнакове ціле число в 2 байтах: від 0 до 65 535
• uint32 Беззнакове ціле число в 4 байтах: від 0 до 4 294 967 295
• uint64 Беззнакове ціле число в 8 байтах: від 0 до 264 − 1
• float_ Тип числа з плаваючою комою за замовчуванням, інша назва для float64
• float32 Знакове число з плаваючою комою звичайної точності: 10−38 до 1038 з 7 точними знаками після десяткової коми.
• float64 Знакове число з плаваючою комою подвійної точности:10−308 до 10308 с 15 точними знаками після десяткової
коми.
• complex_Тип комплексного числа за замовчуванням, інше ім'я для типу complex128
• complex64 Комплексне число звичайної точності (представлене 32-бітними компонентами з плаваючою комою для
дійсної та уявної частин)
• complex128 Комплексне число подвійної точності (представлене 64-бітними компонентами з плаваючою
комою для дійсної та уявної частин)
• bool_ Логічний тип за замовчуванням, представлений 1 байтом
Також досить часто для визначення аргументу dtype використовується рядок, що складається з букви, яка визначає розширену
категорію типу даних (ціле число, непідписане ціле число, комплексне число і т. д.), За яким слідує число, відповідне числу
байтів даного типу.
Типи даних NumPy
• Наприклад:
b = np.zeros((3, 3), dtype="u4")
print(b)
Результат:
[[0 0 0]
[0 0 0]
[0 0 0]]
• Дана інструкція створює матрицю виміру 3 на 3 беззнакових 32-бітних
(4-байтових) цілих чисел (еквівалентних типу np.uint32). Список букв
для підтримуваних типів даних і їх значення наведені нижче в таблиці.
Типи даних NumPy
Буква Опис:
i Знакове ціле число
u Беззнакове ціле число
f Число с плаваючою комою
c Комплексне число з плаваючою комою
b Логічне значення
S, a Рядок (послідовність символів фіксованої довжини)
U Unicode

Приклад:
import numpy as np
a = np.array([u"\u2211", u"\u220F"], dtype="U")
print(a) # ['∑' '∏']
Арифметичні операції
import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)
print(a - b)
print(a * b)
print(a / b)
Результат:
[5 7 9]
[-3 -3 -3]
[ 4 10 18]
[0.25 0.4 0.5 ]
Арифметичні операції
import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

b = np.array([[2, 2, 2], [3, 3, 3], [4, 4, 4]])
print(a + b)
print(a - b)
print(a * b)
print(a / b)
Арифметичні операції
Результат:
[[ 3 4 5]
[ 7 8 9]
[11 12 13]]

[[-1 0 1]
[ 1 2 3]
[ 3 4 5]]

[[ 2 4 6]
[12 15 18]
[28 32 36]]

[[0.5 1. 1.5 ]
[1.33333333 1.66666667 2. ]
[1.75 2. 2.25 ]]
Агрегація в NumPy
• Пакет NumPy містить досить великий набір функцій агрегації

Наприклад:
min — мінімальне значення
max — максимальне значення
sum — сума всіх елементів
mean — середнє арифметичне
prod — множення всіх елементів
Агрегація в NumPy
Масив
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a.min())
print(a.max())
print(a.sum())
print(a.mean())
print(a.prod())
Результат:
1
5
15
3.0
120
Агрегація в NumPy
Матриця
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a.min())
print(a.max())
print(a.sum())
print(a.mean())
print(a.prod())
Результат:
1
9
45
5.0
362880
Лінійна алгебра в Python
• В Numpy є ще один спосіб створення матриць - це використання
об'єкта типу matrix. Матрицю можна задати як список:
import numpy as np
a = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
Результат:
[[1 2 3]
[4 5 6]
[7 8 9]]
Лінійна алгебра в Python
• Для побудови діагональної матриці b з матриці a можна скористатися методом diag. Який повертає
основну діагональ матриці і створює діагональну матрицю.
import numpy as np
a = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
diag = np.diag(a)
print(diag)
b = np.diag(diag)
print(b)
Результат:
[1 5 9]

[[1 0 0]
[0 5 0]
[0 0 9]]
Лінійна алгебра в Python
Для створення одиничної матриці можна використовувати метод identity, але є
і альтернативний варіант метод eye, який дозволяє встановити діагональне
зміщення з одинарними значеннями. Зсув встановлювається через значення
ключа k
import numpy as np
a = np.eye(4, k=-1, dtype=float)
print(a)
Результат:
[[0. 0. 0. 0.]
[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]]
Розмірність вектора або матриці
• Розмірність вектора або матриці також може бути змінена методом reshape

import numpy as np

a = np.matrix("1,2,3;4,5,6")
b = a.reshape((3, 2))
print(b)
Ми трансформували матрицю розмірності 2×3 на розмірність 3×2

[[1 2]
[3 4]
[5 6]]
Транспонування матриць в NumPy
• Нагадаємо, що процес транспонування матриці полягає в заміні
рядків матриці її стовпцями, а стовпців, відповідно, рядками.
Отримана матриця називається транспонованою матрицею.
Символом операції транспонування є буква T.
Транспонування матриць в NumPy
import numpy as np
a = np.matrix("1,2,3;4,5,6;7,8,9")
print(a)
b = a.T
print(b)
Результат
[[1 2 3]
[4 5 6]
[7 8 9]]

[[1 4 7]
[2 5 8]
[3 6 9]]
Лінійна алгебра в Python
• Також є можливість перетворення матриці в плоский вектор за
допомогою методу flatten

import numpy as np
a = np.matrix([[1, 2, 3], [4, 5, 6]])
b = a.flatten()
print(b)
[[1 2 3 4 5 6]]
Множення матриць
• Множити можна тільки матриці, де кількість стовпців першої
матриці дорівнює кількості рядків другої матриці.
Множення матриць
• Давайте помножимо матриці на Python. Для цього використовують метод
dot з бібліотеки Numpy.

import numpy as np
a = np.matrix("1,2,3;0,1,2")
b = np.matrix("1,2;0,4;-1,0")
c = a.dot(b)
print(c)

Результат
[[-2 10]
[-2 4]]
Визначник
• Для роботи з лінійною алгеброю пакет numpy містить пакет linalg.
Для обчислення визначника матриці використовується функція
det із пакета linalg. У зв'язку з особливістю роботи Python з
числами з плаваючою комою, ми будемо використовувати
функцію для округлення чисел round

import numpy as np
a = np.matrix("1,0,3;-1,-1,2;4,7,2")
det = round(np.linalg.det(a))
print(det) # -25
Обернена матриця
• Для отримання оберненої матриці необхідно використовувати
функцію inv з пакета linalg.
• Знайти 𝐴−1
Обернена матриця
import numpy as np
a = np.matrix(1,0,3;-1,-1,2;4,7,2")
a_inv = np.linalg.inv(a)
print(a_inv)
Результат
[[ 0.64 -0.84 -0.12]
[-0.4 0.4 0.2 ]
[ 0.12 0.28 0.04]]
Власні числа і власні вектори
• Для обчислення власних значень і власних векторів матриці n×n
використовується метод np.linalg.eig, що повертає власні значення
w як масив розміру (n,) і і нормалізовані власні вктори v як
матрицю розміру n×n.
• Відзначимо, що власні вектори організовані в стовпці. Якщо
збіжність не забезпечується при обчисленні власного значення з
якихось причин, викидається виняток LinAlgError.
Власні числа і власні вектори
import numpy as np
a = np.matrix("1,0,3;-1,-1,2;4,7,2")
w, v = np.linalg.eig(a)
print(w)
print(v)
[-4.76589969 0.89322087 5.87267883]
[[ 0.39688712 0.86992789 0.5167325 ]
[ 0.51050076 -0.49220599 0.16905322]
[-0.76280377 -0.03096338 0.8392905 ]]
Розв’язання систем лінійних рівнянь
• Розв'яжемо наступну систему лінійних рівнянь різними
способами:
Розв’язання системи в матричному вигляді
import numpy as np
a = np.matrix("1,2,5;1,-1,3;3,-6,-1")
b = np.matrix("-9;2;25")
a_inv = np.linalg.inv(a)
x = a_inv.dot(b)
print(x)
Результат
[[ 2.]
[-3.]
[-1.]]
 Розв’язання системи методом Крамера
import numpy as np
a = np.matrix("1,2,5;1,-1,3;3,-6,-1")
b = np.matrix("-9;2;25")
a_det = round(np.linalg.det(a))
a_1 = np.matrix(a)
a_1[:, 0] = b
a_2 = np.matrix(a)
a_2[:, 1] = b
a_3 = np.matrix(a)
a_3[:, 2] = b
x=[
round(np.linalg.det(a_1)) / a_det,
round(np.linalg.det(a_2)) / a_det,
round(np.linalg.det(a_3)) / a_det,
]
print(x)
[2.0, -3.0, -1.0]
Розв’язання систем лінійних рівнянь
• Ми вирішували системи безпосередньо, але NumPy надає готовий
інструмент для вирішення систем лінійних рівнянь – метод розв'язання

import numpy as np
a = np.matrix("1,2,5;1,-1,3;3,-6,-1")
b = np.matrix("-9;2;25")
x = np.linalg.solve(a, b)
print(x)
Результат
[[ 2.]
[-3.]
[-1.]]