Введение в NumPy

NumPy (сокращение от Numerical Python) — это библиотека Python,

которая обеспечивает высокоэффективную работу с многомерными
массивами и матрицами, а также предоставляет обширный набор функций
для выполнения математических и статистических операций над ними. Это
один из ключевых инструментов для научных вычислений в Python и основа
для многих других библиотек, таких как Pandas, SciPy, Matplotlib, и
библиотек для машинного обучения, таких как TensorFlow и PyTorch.

Почему NumPy?

1. Эффективная работа с массивами:

NumPy значительно ускоряет работу с данными по сравнению со
стандартными списками Python за счет использования низкоуровневого кода
на C, что позволяет обрабатывать большие массивы данных быстро и
эффективно.

2. Многомерные массивы (ndarray):

Основной структурой данных в NumPy является ndarray, который может
содержать элементы одного типа данных (например, целые числа или числа
с плавающей точкой) и поддерживает сложные операции над массивами
любой размерности.

3. Богатый набор функций:

NumPy предоставляет множество встроенных функций для работы с
массивами: математические операции, линейная алгебра, статистика, работа
с массивами случайных чисел, и многие другие.

4. Совместимость с другими библиотеками:

NumPy является основой для многих библиотек Python. Он интегрируется
с такими библиотеками, как Pandas (работа с табличными данными),
Matplotlib (визуализация данных), SciPy (научные вычисления) и другие.

История и развитие NumPy

NumPy был создан на основе Numeric и Numarray — двух библиотек,

которые изначально разрабатывались для выполнения численных
вычислений. В 2005 году разработчик Трэвис Олифант объединил их
функционал и создал NumPy, сделав его открытым проектом. С тех пор
библиотека постоянно развивается, расширяя свой функционал и улучшая
производительность.
 Основные функции NumPy

- Многомерные массивы: NumPy позволяет работать с массивами различной

размерности, начиная с одномерных и заканчивая многомерными, что
упрощает работу с большими объемами данных.
- Эффективные математические операции: NumPy включает функции для
работы с арифметическими операциями, тригонометрией, экспонентами,
логарифмами и многими другими математическими операциями.
- Линейная алгебра: NumPy предоставляет инструменты для работы с
матрицами, решения систем уравнений, нахождения собственных значений
и выполнения других операций линейной алгебры.
- Генерация случайных чисел: NumPy содержит модуль `[Link]`,
который предоставляет возможности для генерации случайных чисел и
распределений, полезных для статистики и симуляций.
- Быстрая обработка больших данных: Благодаря своей архитектуре,
построенной на C, NumPy работает с массивами данных значительно
быстрее, чем стандартные списки Python.

---

Ключевые преимущества NumPy

1. Производительность: Операции с массивами NumPy значительно быстрее,

чем со списками Python, благодаря низкоуровневой реализации.
2. Масштабируемость: NumPy легко работает с большими многомерными
массивами данных и позволяет выполнять сложные вычисления над ними.
3. Универсальность: NumPy включает в себя функции для работы с
базовыми арифметическими операциями, статистикой, линейной алгеброй,
генерацией случайных чисел и многим другим.

NumPy в практике

NumPy широко используется в различных областях:

- Анализ данных: NumPy позволяет эффективно работать с большими
наборами данных, выполняя агрегирование, фильтрацию и сортировку
данных.
- Машинное обучение: Большинство библиотек для машинного обучения,
такие как TensorFlow и PyTorch, используют массивы NumPy для
представления данных и выполнения вычислений.
- Научные вычисления: NumPy является стандартом для научных
вычислений в Python, включая биоинформатику, обработку изображений и
сигналов.
- Математическое моделирование: NumPy применяется для создания
математических моделей, численных симуляций и анализа данных.

Вывод:
NumPy — это ключевая библиотека для научных вычислений в Python,
которая значительно упрощает работу с большими массивами данных и
позволяет выполнять сложные математические и статистические
вычисления с высокой эффективностью. Она является основой для многих
других библиотек, используемых в науке, аналитике данных и машинном
обучении.

2. Структуры данных в NumPy

Основной структурой данных в NumPy является ndarray (N-dimensional

array) — многомерный массив, который поддерживает операции над
элементами и позволяет легко манипулировать данными. Ниже рассмотрим
основные структуры данных и их создание в NumPy.

2.1. Одномерные массивы

Одномерный массив — это самая простая форма массива, которая содержит

элементы в одном направлении.

Пример создания одномерного массива:

```python
import numpy as np

Создание одномерного массива

arr = [Link]([1, 2, 3, 4])
print(arr)
```

2.2. Многомерные массивы

NumPy также позволяет создавать массивы с несколькими измерениями.

Например, двумерный массив представляет собой матрицу, а трехмерный
массив может быть представлен как многослойная матрица.

Пример создания двумерного массива (матрицы):

```python
import numpy as np
 Создание двумерного массива
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)
```

Пример создания трехмерного массива:

```python
Трехмерный массив
three_d = [Link]([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(three_d)
```

2.3. Атрибуты массивов

NumPy-массивы имеют ряд атрибутов, которые помогают работать с

массивами и получать информацию о них.

- [Link] — возвращает размеры массива (его форму).

- [Link] — возвращает количество измерений массива.
- [Link] — возвращает общее количество элементов в массиве.
- [Link] — показывает тип данных элементов массива.

Пример:

```python
import numpy as np

arr = [Link]([[1, 2, 3], [4, 5, 6]])

Форма массива (количество строк и столбцов)

print([Link]) (2, 3)

Количество измерений
print([Link]) 2

Количество элементов
print([Link]) 6

Тип данных элементов массива

print([Link]) int64 (или другой тип в зависимости от платформы)
```
2.4. Специальные массивы

NumPy предоставляет встроенные функции для создания специальных

массивов, таких как массивы, заполненные нулями, единицами или линейно
распределенными значениями.

- [Link](shape) — создает массив, заполненный нулями.

- [Link](shape) — создает массив, заполненный единицами.
- [Link](start, stop, step) — создает массив чисел с указанным шагом.
- [Link](start, stop, num) — генерирует массив из `num` чисел,
равномерно распределенных между `start` и `stop`.

Примеры создания специальных массивов:

```python
Массив из нулей размером 2x3
zeros = [Link]((2, 3))

Массив из единиц размером 3x3

ones = [Link]((3, 3))

Массив чисел от 0 до 9 с шагом 2

arange = [Link](0, 10, 2)

Массив 5 чисел, равномерно распределённых между 0 и 1

linspace = [Link](0, 1, 5)

print(zeros)
print(ones)
print(arange)
print(linspace)
```

2.5. Изменение формы массивов

NumPy поддерживает изменение формы массива с помощью метода reshape.

Это позволяет изменять количество строк и столбцов в массиве, сохраняя
общее количество элементов.

Пример:

```python
arr = [Link]([1, 2, 3, 4, 5, 6])

Преобразование одномерного массива в двумерный массив 2x3

reshaped_arr = [Link](2, 3)
print(reshaped_arr)
```

2.6. Типы данных в массивах

Все элементы массива должны быть одного типа данных. NumPy

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

Пример указания типа данных:

```python
arr = [Link]([1.5, 2.3, 3.7], dtype=np.int32)
print(arr) Все элементы будут преобразованы в целые числа
```

2.7. Индексация и срезы массивов

NumPy поддерживает сложную индексацию и срезы (slicing), что позволяет

выбирать отдельные элементы или группы элементов из массива.

- Одномерные массивы:
```python
arr = [Link]([10, 20, 30, 40])
print(arr[2]) Получение элемента с индексом 2 (30)
```

- Многомерные массивы:
```python
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Доступ к элементу в первой строке и втором столбце

print(matrix[0, 1]) 2

Срез массива (все строки, первый и второй столбцы)

print(matrix[:, :2])
```
Вывод:
NumPy предоставляет мощные инструменты для работы с многомерными
массивами и их манипуляции. Благодаря гибкой системе создания массивов,
изменению их формы и поддержке операций с элементами массивов, NumPy
является неотъемлемой частью любой работы с данными на Python.
3. Операции над массивами в NumPy

NumPy предоставляет множество встроенных функций для выполнения

различных операций над массивами. Это делает работу с массивами и
матрицами более удобной и эффективной. В этой части рассмотрим
ключевые операции, такие как арифметические действия, логические
операции, агрегирование данных, трансформации и линейную алгебру.

3.1. Арифметические операции

NumPy позволяет выполнять арифметические операции с массивами на

уровне элементов. Операции производятся поэлементно, то есть
выполняются для каждой пары элементов массивов одинакового размера.

- Сложение:
```python
import numpy as np

a = [Link]([1, 2, 3])
b = [Link]([4, 5, 6])
result = a + b [5, 7, 9]
```

- Вычитание:
```python
result = a - b [-3, -3, -3]
```

- Умножение:
```python
result = a * b [4, 10, 18]
```

- Деление:
```python
result = a / b [0.25, 0.4, 0.5]
```

Также возможны операции с массивами и скалярами. Например, при

умножении массива на число каждый элемент массива будет умножен на это
число:

```python
result = a * 2 [2, 4, 6]
```

3.2. Логические операции

NumPy поддерживает выполнение логических операций, таких как

сравнение элементов массива.

- Сравнение массивов:
```python
result = a > b [False, False, False]
```

- Операции AND, OR:

Для выполнения логических операций над массивами можно использовать
функции `np.logical_and`, `np.logical_or`, и другие.

Пример:
```python
result = np.logical_and(a > 1, b < 6) [False, True, True]
```

3.3. Агрегационные операции

NumPy предлагает ряд функций для выполнения агрегирующих операций

над массивами, таких как нахождение суммы, среднего, максимума,
минимума и т.д.

- Сумма элементов:
```python
result = [Link](a) 6
```

- Минимум и максимум:
```python
min_val = [Link](a) 1
max_val = [Link](a) 3
```

- Среднее значение:
```python
mean_val = [Link](a) 2.0
```
- Стандартное отклонение:
```python
std_val = [Link](a) 0.816496580927726
```

Эти функции также могут применяться вдоль определенной оси

многомерного массива:

```python
matrix = [Link]([[1, 2, 3], [4, 5, 6]])
result = [Link](matrix, axis=0) Сумма по столбцам: [5, 7, 9]
result = [Link](matrix, axis=1) Сумма по строкам: [6, 15]
```

3.4. Трансформации массивов

NumPy позволяет легко изменять форму массивов и производить другие

трансформации, такие как транспонирование, объединение массивов и
разделение массивов.

- Изменение формы массива (`reshape`):

Преобразование массива в другую форму с тем же количеством элементов:

```python
arr = [Link]([1, 2, 3, 4, 5, 6])
reshaped_arr = [Link](2, 3) [[1, 2, 3], [4, 5, 6]]
```

- Транспонирование массива (`transpose`):

Меняет строки и столбцы местами в двумерных массивах.

```python
matrix = [Link]([[1, 2, 3], [4, 5, 6]])
transposed = matrix.T [[1, 4], [2, 5], [3, 6]]
```

- Конкатенация массивов:
Объединение массивов вдоль определенной оси с помощью
`[Link]`.

```python
arr1 = [Link]([1, 2, 3])
 arr2 = [Link]([4, 5, 6])
result = [Link]((arr1, arr2)) [1, 2, 3, 4, 5, 6]
```

3.5. Операции линейной алгебры

NumPy включает мощные инструменты для выполнения операций линейной

алгебры, таких как умножение матриц, нахождение обратной матрицы и
решение систем линейных уравнений.

- Скалярное произведение векторов:

```python
a = [Link]([1, 2])
b = [Link]([3, 4])
result = [Link](a, b) 11 (1*3 + 2*4)
```

- Умножение матриц:
Для умножения двух матриц используется функция `[Link]` или оператор
`@`.

```python
A = [Link]([[1, 2], [3, 4]])
B = [Link]([[5, 6], [7, 8]])
result = [Link](A, B) [[19, 22], [43, 50]]
```

- Нахождение обратной матрицы:

С помощью функции `[Link]` можно найти обратную матрицу.

```python
matrix = [Link]([[1, 2], [3, 4]])
inv_matrix = [Link](matrix)
```

- Собственные значения и векторы:

NumPy позволяет находить собственные значения и собственные векторы с
помощью функции `[Link]`.

```python
vals, vecs = [Link](matrix)
```
Вывод:
NumPy предоставляет мощный набор инструментов для работы с
массивами, включая арифметические, логические и агрегирующие
операции, а также трансформации и операции линейной алгебры. Эти
функции делают работу с большими наборами данных и многомерными
массивами быстрой и эффективной.

Индексация и срезы в NumPy

Индексация и срезы (slicing) — это важные инструменты работы с

массивами в NumPy, которые позволяют получить доступ к отдельным
элементам или частям массивов.

1. Индексация (Indexing)

Индексация позволяет извлекать отдельные элементы массива, указывая их

положение с помощью индексов. В NumPy индексация начинается с нуля, то
есть первый элемент массива имеет индекс 0, второй — 1, и так далее.

Одномерный массив

```python
import numpy as np

Одномерный массив
arr = [Link]([10, 20, 30, 40, 50])

Доступ к элементу с индексом 2 (третий элемент)

print(arr[2]) 30
```

Многомерный массив

Для многомерных массивов индексация выполняется с указанием индексов

для каждого измерения.

```python
Двумерный массив (матрица)
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Доступ к элементу во второй строке и третьем столбце

print(matrix[1, 2]) 6
```
2. Срезы (Slicing)

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

каждого измерения. Формат срезов: `start:stop:step`.

- start — индекс начала среза (включительно).

- stop — индекс конца среза (не включается в срез).
- step — шаг среза (по умолчанию 1).

Одномерный массив

```python
Срез элементов с индексами от 1 до 3
print(arr[1:4]) [20, 30, 40]

Срез элементов с шагом 2

print(arr[::2]) [10, 30, 50]
```

Многомерный массив

Для многомерных массивов можно задавать срезы для каждого измерения.

```python
Срез всех строк, но только столбцов с индексами 1 и 2
print(matrix[:, 1:3])
[[2, 3],
[5, 6],
[8, 9]]
```

Отрицательные индексы

NumPy поддерживает использование отрицательных индексов, которые

отсчитываются с конца массива.

```python
Последний элемент массива
print(arr[-1]) 50

Срез последних двух элементов

print(arr[-2:]) [40, 50]
```

Срезы в многомерных массивах

Для двумерных массивов можно использовать срезы по строкам и столбцам:

```python
Срез первой и второй строк, первого и второго столбцов
print(matrix[:2, :2])
[[1, 2],
[4, 5]]
```

3. Изменение значений с помощью индексов и срезов

NumPy позволяет изменять значения элементов массива, используя индексы

и срезы.

```python
Изменение значения элемента массива с индексом 2
arr[2] = 100
print(arr) [10, 20, 100, 40, 50]

Замена части массива с помощью среза

arr[1:4] = [200, 300, 400]
print(arr) [10, 200, 300, 400, 50]
```

4. Булева индексация (Boolean Indexing)

Булева индексация позволяет извлекать элементы массива,

удовлетворяющие определенному условию.

```python
Массив
arr = [Link]([10, 20, 30, 40, 50])

Индексация элементов, которые больше 25

result = arr[arr > 25]
print(result) [30, 40, 50]
```
Вывод:
Индексация и срезы — это мощные инструменты NumPy, которые делают
работу с массивами гибкой и удобной. С их помощью можно извлекать,
модифицировать и манипулировать частями массивов.
5. Преобразование формы массива в NumPy

NumPy предоставляет мощные возможности для изменения формы

массивов без изменения данных, что делает работу с ними гибкой и
удобной. Основные операции включают изменение формы массива,
транспонирование, растяжение (флэттенинг), а также добавление и удаление
осей.

5.1. Изменение формы массива: `reshape`

Функция `reshape()` позволяет преобразовать массив в новую форму, при

этом количество элементов должно оставаться тем же.

Пример:
```python
import numpy as np

Одномерный массив
arr = [Link]([1, 2, 3, 4, 5, 6])

Преобразование в двумерный массив 2x3

reshaped_arr = [Link](2, 3)
print(reshaped_arr)
Output:
[[1, 2, 3],
[4, 5, 6]]
```

Если указывать в одном из измерений `-1`, NumPy автоматически подберет

размер на основе других размеров и общего числа элементов.

```python
Автоматический расчет одного измерения
reshaped_arr = [Link](3, -1) [[1, 2], [3, 4], [5, 6]]
```

5.2. Вытягивание массива: `ravel` и `flatten`

Для преобразования многомерного массива в одномерный можно

использовать методы `ravel()` и `flatten()`.

- `ravel()` возвращает «вид» (view) на исходные данные. Любые изменения в

новом массиве будут отражаться в исходном.
- `flatten()` возвращает копию данных, и изменения в новом массиве не
повлияют на исходный.

```python
Двумерный массив
matrix = [Link]([[1, 2, 3], [4, 5, 6]])

Вытягивание в одномерный массив

raveled = [Link]() [1, 2, 3, 4, 5, 6]
flattened = [Link]() [1, 2, 3, 4, 5, 6]
```

5.3. Транспонирование массива: `transpose`

Метод `transpose()` меняет местами оси массива. В двумерных массивах это

означает замену строк на столбцы и наоборот.

```python
Транспонирование двумерного массива
transposed = [Link]()
print(transposed)
Output:
[[1, 4],
[2, 5],
[3, 6]]
```
5.4. Изменение размерности: `newaxis` и `expand_dims`

NumPy позволяет добавлять новые оси к массиву с помощью `newaxis` или

функции `expand_dims()`, что полезно для работы с векторами и
многомерными массивами.

- `newaxis` добавляет новую ось, увеличивая количество измерений массива.

```python
arr = [Link]([1, 2, 3])

Добавление новой оси (превращение одномерного массива в двумерный)

arr_2d = arr[:, [Link]]
print(arr_2d)
Output:
[[1],
[2],
 [3]]
```
- `expand_dims()` аналогично добавляет ось в указанное положение.

```python
arr_2d = np.expand_dims(arr, axis=0)
print(arr_2d)
Output:
[[1, 2, 3]] Ось добавлена в начало
```
5.5. Сжатие или объединение осей: `squeeze`

Функция `squeeze()` удаляет оси размером 1, уменьшая размерность

массива.

```python
Массив с одной осью размером 1
arr = [Link]([[[1], [2], [3]]])

Удаление оси размером 1

squeezed = [Link](arr)
print(squeezed)
Output:
[1, 2, 3]
```
Вывод:
Преобразование формы массива — важная операция, которая позволяет
эффективно работать с массивами различной размерности в NumPy. Эти
инструменты обеспечивают гибкость работы с данными, начиная от
простого изменения формы и заканчивая добавлением или удалением осей.
6. Линейная алгебра в NumPy

Модуль NumPy предоставляет мощные функции для выполнения операций

линейной алгебры. Эти операции необходимы для работы с векторами,
матрицами и тензорами, особенно в области машинного обучения, научных
вычислений и обработки данных.

6.1. Матрицы и векторы в NumPy

В NumPy матрицы и векторы представлены с помощью многомерных

массивов. Основные операции над ними выполняются через встроенные
функции.

- Создание вектора:
```python
import numpy as np
vector = [Link]([1, 2, 3]) Одномерный массив (вектор)
```

- Создание матрицы:
```python
matrix = [Link]([[1, 2], [3, 4]]) Двумерный массив (матрица)
```

6.2. Скалярное произведение векторов

Скалярное произведение двух векторов — это сумма произведений их

соответствующих элементов. В NumPy для этого используется функция
`dot()`.

```python
Скалярное произведение векторов
v1 = [Link]([1, 2, 3])
v2 = [Link]([4, 5, 6])
result = [Link](v1, v2) 1*4 + 2*5 + 3*6 = 32
```

6.3. Умножение матриц

Для умножения матриц в NumPy также используется функция `dot()` или

оператор `@`. Важно отметить, что умножение массивов `*` в NumPy
производит поэлементное умножение, а не матричное.
```python
Умножение двух матриц
A = [Link]([[1, 2], [3, 4]])
B = [Link]([[5, 6], [7, 8]])
result = [Link](A, B)
print(result)
Output:
[[19, 22],
[43, 50]]
```

6.4. Транспонирование матрицы

Транспонирование меняет строки и столбцы матрицы местами. Для

транспонирования матрицы используется функция `transpose()` или атрибут
`T`.

```python
Транспонирование матрицы
A = [Link]([[1, 2, 3], [4, 5, 6]])
transposed_A = A.T
print(transposed_A)
Output:
[[1, 4],
[2, 5],
[3, 6]]
```
6.5. Нахождение обратной матрицы

Чтобы найти обратную матрицу, можно использовать функцию

`[Link]()`. Обратная матрица существует только для квадратных
матриц и при условии, что определитель матрицы не равен нулю.

```python
Обратная матрица
matrix = [Link]([[1, 2], [3, 4]])
inv_matrix = [Link](matrix)
print(inv_matrix)
Output:
[[-2. , 1. ],
[ 1.5, -0.5]]
```
6.6. Определитель матрицы
Определитель матрицы — это важная характеристика квадратных матриц,
которая может быть вычислена с помощью функции `[Link]()`.

```python
Вычисление определителя
matrix = [Link]([[1, 2], [3, 4]])
det = [Link](matrix)
print(det) -2.0
```
6.7. Системы линейных уравнений

NumPy может решать системы линейных уравнений с помощью функции

`[Link]()`. Это особенно полезно при необходимости решения
уравнений вида `Ax = b`, где `A` — матрица коэффициентов, а `b` — вектор
решений.

```python
Решение системы линейных уравнений
A = [Link]([[3, 1], [1, 2]])
b = [Link]([9, 8])
x = [Link](A, b)
print(x) [2., 3.]
```
6.8. Собственные значения и собственные векторы

Собственные значения и собственные векторы — это важные понятия

линейной алгебры. Их можно найти с помощью функции `[Link]()`.

```python
Собственные значения и собственные векторы
matrix = [Link]([[1, 2], [2, 1]])
eigenvalues, eigenvectors = [Link](matrix)
print(eigenvalues) Собственные значения
print(eigenvectors) Собственные векторы
```

Вывод:
NumPy предоставляет обширные возможности для выполнения операций
линейной алгебры, включая умножение матриц, транспонирование,
вычисление определителя, нахождение обратной матрицы и решение систем
линейных уравнений. Эти функции делают его незаменимым инструментом
для анализа данных, научных и инженерных вычислений
Общий вывод по NumPy

NumPy является одним из самых мощных и популярных инструментов для

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

Ключевыми аспектами использования NumPy являются:

1. Массивы и их структуры: NumPy предоставляет многофункциональные

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

2. Индексация и срезы: Позволяют гибко обращаться к элементам массивов,

изменять их и извлекать подмножества данных.

3. Операции над массивами: В NumPy реализованы различные

математические операции, такие как сложение, умножение,
транспонирование, нахождение скалярных и матричных произведений.

4. Линейная алгебра: Встроенные функции для работы с матрицами,

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

Благодаря этим возможностям, NumPy — это основной модуль для ученых,

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

Тема: Основы работы с библиотекой NumPy

Цель:
Изучить основные операции библиотеки NumPy, включая создание
массивов, выполнение математических операций, индексирование и срезы,
линейную алгебру.

Задания:

Задание 1. Создание и базовые операции с массивами

1. Создайте одномерный массив чисел от 1 до 10.

2. Создайте двумерный массив размером 3x3 со случайными целыми
числами от 0 до 20.
3. Найдите сумму всех элементов созданных массивов.
4. Найдите среднее значение элементов каждого массива.

Задание 2. Индексация и срезы

1. Из двумерного массива извлеките все элементы второй строки.

2. Извлеките все элементы второго столбца.
3. Замените все элементы первой строки на число 100.

Задание 3. Линейная алгебра

1. Создайте две матрицы размером 2x2 с произвольными значениями.

2. Найдите их произведение (используйте `[Link]()`).
3. Вычислите определитель одной из матриц.
4. Найдите обратную матрицу для одной из них.

Задание 4. Работа с большими массивами

1. Создайте массив из 1000 случайных чисел с нормальным распределением.

2. Найдите минимальное, максимальное и среднее значение этого массива.
3. Постройте гистограмму распределения значений (используя библиотеку
`matplotlib`).