Основы работы с NumPy
Покажем основные методы обработки многомерных массивов и научим делать простые фильтры для изображений. В конце статьи – 10 инженерных и экономических задач с решениями. ← Часть 23 Основы веб-разработки на Flask NumPy – одна из самых популярных библиотек для инженерных и научных вычислений в Python: она содержит множество методов для работы с многомерными массивами и матрицами и отличается высокой скоростью обработки больших объемов данных. Мощная функциональность NumPy используется в нескольких других популярных библиотеках – Pandas, SciPy, Matplotlib, Scikit-learn и TensorFlow. NumPy используется везде, где нужна быстрая обработка больших массивов данных: NumPy может работать с данными из списков, кортежей и словарей, однако основная цель библиотеки – предоставление мощного инструментария для работы с многомерными массивами и матрицами. Все, что можно сделать с массивами (сортировку, фильтрацию, изменение формы, все виды статистического анализа, любые вычисления и т.п.), NumPy делает максимально просто и эффективно. Массивы NumPy используют меньше памяти и работают быстрее, чем обычные списки Python: инструменты библиотеки, для которых критична скорость, реализованы на C/C++. Кроме того, NumPy использует собственный тип данных, который называется ndarray (n-размерным массивом). Сравним быстродействие обычного Python кода и метода NumPy на примере сложения двух матриц 1000 х 1000: Результат: Ключевые особенности ndarray: Больше полезных материалов вы найдете на нашем телеграм-канале «Библиотека питониста» Интересно, перейти к каналу NumPy предоставляет несколько способов создания массивов, вот основные: Результат: Продемонстрируем базовые операции на примере двумерного массива: Результат: Методы NumPy позволяют легко проводить любые манипуляции над массивами и получать всевозможную статистическую информацию о них: Результат: reshape() – меняет форму массива без изменения данных: Результат: concatenate() – объединяет массивы по строкам или по столбцам: Результат: flatten() – превращает многомерный массив в одномерный: Результат; argmax() и argmin() – возвращают индексы максимального (минимального) элемента массива: Результат: where() – выбирает из массива элементы, удовлетворяющие определенному условию: Результат: В NumPy есть еще один метод, похожий на where() – argwhere(). Он возвращает индексы элементов, соответствующих условию, в виде массива: Результат: nonzero() – возвращает индексы ненулевых элементов: Результат: unique() – возвращает уникальные элементы: Результат: sort() – сортирует массив по возрастанию / убыванию: Результат: diag() – возвращает диагональ матрицы. Также метод можно использовать для создания диагональной матрицы из заданных элементов: Результат: trace() вычисляет след матрицы, то есть сумму элементов на ее главной диагонали: Результат: Все возможности библиотеки можно рассмотреть только в объемной книге, поэтому приведем лишь несколько примеров. NumPy поддерживает загрузку данных из файлов различных форматов. Так, например, можно сохранить массив и загрузить его из текстового файла (txt, csv, json): Однако при работе с очень большими объемами информации стоит использовать собственные бинарные форматы NumPy – npy и npz: они экономят до 50% места на диске и загружаются быстрее, чем любые текстовые файлы. Так сохраняют и загружают npy файлы: С помощью NumPy изображения можно представить в виде трехмерных массивов, где каждый пиксель является результатом смешивания красного, зеленого и синего цветов (RGB). А четырехмерные массивы можно использовать для работы с изображениями с альфа-каналом (RGBA). Возьмем любое цветное изображение: И обработаем его: Приведенный выше код загружает изображение в массив NumPy, после чего: В итоге мы получаем разноцветный коллаж, где первая четверть – черно-белая, а остальные три – красная, зеленая и синяя: NumPy (вместе с Matplotlib) отлично визуализирует большие объемы данных. На Yahoo Finance можно скачать исторические данные о стоимости любых акций и криптовалют. Скачаем, к примеру, csv файл с информацией о стоимости Litecoin за последние 5 лет. Код для визуализации цен закрытия будет выглядеть так: Результат: Напишите программу, которая: Пример вывода: Решение: Для пункта проката велосипедов нужно написать программу, которая определит самый прибыльный сезон. Пример вывода: Решение: Компания «ГрузАвто» производит грузовики на 4 заводах. Отчет о выполнении производственного плана по месяцам и заводам можно представить в виде массива: Напишите программу, которая определит: Пример вывода: Решение: Для кондитерской фабрики нужно написать программу, которая обрабатывает массив с показателями годового плана производства по 12 основным видам продукции и массив с ценами на сырье: Необходимо определить: Пример вывода: Решение: Напишите программу, которая будет определять, соответствует ли состав портфеля допустимому уровню риска. Пример ввода: Вывод: Решение: Напишите программу, которая будет анализировать исторические данные о курсе биткоина с 01.01.22, выбирая из файла дни, когда: Пример вывода: Решение: Напишите кредитный калькулятор для вычисления переплаты при аннуитетном и дифференцированном способах погашения. Пример вывода: Решение: Напишите программу для мониторинга динамических нагрузок на инженерную конструкцию. У вас есть данные об ускорении, силе и деформации, которые действуют на конструкцию в течение определенного периода времени: Нужно: Пример вывода: Решение: Имеются данные о выручке в нескольких магазинах компании, расположенных в различных городах: Напишите программу, которая определит: Пример вывода: Решение: Имеются массивы с данными о продажах: Напишите программу, которая определит: Пример вывода: Решение: NumPy – мощная и эффективная библиотека, обладающая двумя важными преимуществами: Эти преимущества делают NumPy незаменимым инструментом для научных, инженерных и финансовых вычислений, машинного обучения, обработки и анализа данных. В заключительной главе самоучителя будем изучать Pandas. *** 
Основные сферы применения
Массив ndarray
import numpy as np import time # Определяем две матрицы размером 1000x1000 со случайными целыми числами от 0 до 9 A = np.random.randint(0, 10, size=(1000, 1000)) B = np.random.randint(0, 10, size=(1000, 1000)) # Сложение матриц средствами Python start_time = time.time() C = [[A[i][j] + B[i][j] for j in range(len(A[0]))] for i in range(len(A))] end_time = time.time() # Сложение матриц с помощью NumPy start_time_np = time.time() D = A + B end_time_np = time.time() # Выводим результаты и время выполнения print(f"Время выполнения Python сложения: {end_time - start_time} сек") print(f"Время выполнения NumPy сложения: {end_time_np - start_time_np} сек") # Сравниваем результаты print("Результаты совпадают:", np.array_equal(C, D))
Время выполнения Python сложения: 1.432081937789917 сек Время выполнения NumPy сложения: 0.004000186920166016 сек Результаты совпадают: True Как создать массив в NumPy
import numpy as np # Создание массива из списка a = np.array([1, 2, 3, 4, 5]) print(a) # Создание двумерного массива из списка списков b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(b) # Создание массива из диапазона значений c = np.arange(0, 10, 2) # Создаем массив из значений от 0 до 10 с шагом 2 print(c) # Создание массива из равномерно распределенных значений d = np.linspace(0, 1, 5) # Создаем массив из 5 равномерно распределенных значений от 0 до 1 print(d) # Создание массива из случайных значений e = np.random.rand(3, 3) # Создаем массив из 3x3 случайных значений print(e) # Создание массива из нулей f = np.zeros((2, 3)) # Создаем массив из нулей размером 2x3 print(f) # Создание массива из единиц g = np.ones((3, 3)) # Создаем массив из единиц размером 3x3 print(g)
[1 2 3 4 5] [[1 2 3] [4 5 6] [7 8 9]] [0 2 4 6 8] [0. 0.25 0.5 0.75 1. ] [[0.66777626 0.88439902 0.22572609] [0.09556062 0.40293789 0.58901436] [0.33380993 0.20922535 0.42657995]] [[0. 0. 0.] [0. 0. 0.]] [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]] Основные операции с массивами
import numpy as np # Создаем двумерный массив arr = np.array([[1, 2], [3, 4], [5, 6]]) # Выводим массив на экран print(arr) # Получаем размерность массива print(arr.shape) # Получаем элементы массива print(arr[0, 1]) # Выведет 2 print(arr[2, 0]) # Выведет 5 # Изменяем элементы массива arr[0, 1] = 7 arr[1, 1] = 8 arr[2, 1] = 9 print(arr) # Выводим строку print(arr[1]) # Выведет [3 8] # Выводим столбец print(arr[:, 0]) # Выведет [1 3 5] # Выводим срез print(arr[:2, 1]) # Выведет [7 8]
[[1 2] [3 4] [5 6]] (3, 2) 2 5 [[1 7] [3 8] [5 9]] [3 8] [1 3 5] [7 8]
import numpy as np # Создаем два массива размером 6x6 со случайными целыми числами от 0 до 9 a = np.random.randint(1, 10, size=(6, 6)) b = np.random.randint(1, 10, size=(6, 6)) # Выводим массивы на экран print("Массив a:n", a) print("Массив b:n", b) # Вычитаем массивы d = a - b print("Разность массивов a и b:n", d) # Умножение массивов m = np.dot(a, b) print("Произведение массивов a и b:n", m) # Деление массивов (умножение на обратную матрицу) # Вычисляем обратную матрицу b b_inv = np.linalg.inv(b) # Умножаем матрицу a на обратную матрицу b_inv result = np.dot(a, b_inv) print("Результат деления массива a на b:n", result) # Транспонируем массивы h = np.transpose(a) i = np.transpose(b) print("Массив a после транспонирования:n", h) print("Массив b после транспонирования:n", i) # Получаем статистические параметры массивов std_a = np.std(a) # Стандартное отклонение массива a median_b = np.median(b) # Медиана массива b variance_a = np.var(a) # Дисперсия массива a min_b = np.min(b) # Минимальное значение массива b max_a = np.max(a) # Максимальное значение массива a sum_b = np.sum(b) # Сумма элементов массива b product_a = np.product(a, dtype=np.uint64) # Произведение элементов массива a prod_b = np.prod(b, dtype=np.uint64) # Еще один метод вычисления произведения элементов print("Стандартное отклонение массива a:", std_a) print("Медиана массива b:", median_b) print("Дисперсия массива a:", variance_a) print("Минимальное значение массива b:", min_b) print("Максимальное значение массива a:", max_a) print("Сумма элементов массива b:", sum_b) print("Произведение элементов массива a:", product_a) print("Произведение элементов массива b:", prod_b)
Массив a: [[2 2 3 9 8 2] [4 7 6 6 1 5] [6 8 5 7 6 7] [5 3 2 6 5 5] [8 5 3 7 3 3] [5 8 2 6 1 1]] Массив b: [[4 1 6 4 9 4] [6 8 2 2 3 4] [2 4 9 9 7 6] [9 4 2 9 2 3] [5 8 4 7 9 8] [2 7 4 6 9 9]] Разность массивов a и b: [[-2 1 -3 5 -1 -2] [-2 -1 4 4 -2 1] [ 4 4 -4 -2 -1 1] [-4 -1 0 -3 3 2] [ 3 -3 -1 0 -6 -5] [ 3 1 -2 0 -8 -8]] Произведение массивов a и b: [[151 144 101 188 153 143] [139 151 128 175 165 151] [189 215 163 232 244 218] [131 136 106 163 170 147] [152 133 123 171 176 142] [133 116 84 121 113 99]] Результат деления массива a на b: [[-5.55598908e-01 -1.94654702e+00 4.39719079e-01 -6.62504877e-01 5.72922357e+00 -3.83066719e+00] [-2.90479906e-01 1.16172454e+00 8.37690207e-01 3.86071011e-01 -1.83749512e+00 1.11451424e+00] [ 4.77955521e-03 6.06808428e-01 2.70971518e-01 2.91162700e-01 -3.96898166e-01 5.81057355e-01] [ 3.19791260e-01 -5.26238783e-02 -2.67752634e-01 6.75039017e-01 -7.08788529e-01 1.02033750e+00] [ 5.16972298e-02 2.57315646e-01 1.34998049e-01 5.37065938e-01 4.00897386e-01 -4.29379633e-01] [-1.07915529e+00 -1.51531409e-01 7.47073742e-01 -5.26092470e-01 3.97107881e+00 -3.19444986e+00]] Массив a после транспонирования: [[2 4 6 5 8 5] [2 7 8 3 5 8] [3 6 5 2 3 2] [9 6 7 6 7 6] [8 1 6 5 3 1] [2 5 7 5 3 1]] Массив b после транспонирования: [[4 6 2 9 5 2] [1 8 4 4 8 7] [6 2 9 2 4 4] [4 2 9 9 7 6] [9 3 7 2 9 9] [4 4 6 3 8 9]] Стандартное отклонение массива a: 2.27438772116208 Медиана массива b: 5.5 Дисперсия массива a: 5.172839506172839 Минимальное значение массива b: 1 Максимальное значение массива a: 9 Сумма элементов массива b: 197 Произведение элементов массива a: 18210394348833472512 Произведение элементов массива b: 14758432146536267776 Полезные методы NumPy
import numpy as np # создаем массив размером 3x4 arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) # используем метод reshape() для изменения формы массива на 2x6 new_arr = arr.reshape(2, 6) print("Исходный массив:") print(arr) print("Массив после изменения формы:") print(new_arr)
Исходный массив: [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] Массив после изменения формы: [[ 1 2 3 4 5 6] [ 7 8 9 10 11 12]]
import numpy as np a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) c = np.array([[9, 10], [11, 12]]) #объединяем массивы по горизонтальной оси (по строкам) d = np.concatenate((a, b, c), axis=1) print(d) #объединяем массивы по вертикальной оси (по столбцам) e = np.concatenate((a, b, c), axis=0) print(e)
[[ 1 2 5 6 9 10] [ 3 4 7 8 11 12]] [[ 1 2] [ 3 4] [ 5 6] [ 7 8] [ 9 10] [11 12]]
import numpy as np a = np.array([[1, 2, 9, 8], [7, 5, 3, 4], [2, 1, 5, 6], [4, 8, 7, 8]]) print(a.flatten())
[1 2 9 8 7 5 3 4 2 1 5 6 4 8 7 8]
import numpy as np a = np.array([[4, 2, 9, 89], [17, 5, 3, 14], [25, -5, 5, 6], [4, 18, 17, 8]]) print(f"Индекс максимального элемента: {np.argmax(a)}") print(f"Индекс минимального элемента: {np.argmin(a)}")
Индекс максимального элемента: 3 Индекс минимального элемента: 9
import numpy as np arr = np.array([[14, 22, 91, 19], [11, 51, 32, 14], [25, 22, 50, 60], [14, 18, 17, 28]]) # формируем новый массив из четных элементов исходного, заменяя нечетные на цифру 5 new_arr = np.where(arr % 2 == 0, arr, 5) print(new_arr)
[[14 22 5 5] [ 5 5 32 14] [ 5 22 50 60] [14 18 5 28]]
import numpy as np # Создание двумерного массива arr = np.random.randint(0, 5, size=(5, 5)) print("Массив:") print(arr) result = np.argwhere(arr != 3) print(result)
Массив: [[4 3 0 1 1] [0 0 0 4 1] [1 1 2 0 0] [3 0 0 3 1] [2 2 4 3 0]] [[0 0] [0 2] [0 3] [0 4] [1 0] [1 1] [1 2] [1 3] [1 4] [2 0] [2 1] [2 2] [2 3] [2 4] [3 1] [3 2] [3 4] [4 0] [4 1] [4 2] [4 4]]
import numpy as np # Создание двумерного массива arr = np.random.randint(0, 2, size=(5, 5)) print("Массив:") print(arr) result = np.nonzero(arr) print(result)
Массив: [[0 1 0 0 0] [1 1 0 1 0] [1 0 1 0 1] [1 0 1 1 0] [0 1 0 1 0]] (array([0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4], dtype=int32), array([1, 0, 1, 3, 0, 2, 4, 0, 2, 3, 1, 3], dtype=int32))
import numpy as np # создание массива случайных чисел размером 500x500 arr = np.random.randint(low=0, high=10, size=(500, 500)) # вывод уникальных значений массива unique_values, counts = np.unique(arr, return_counts=True) print(arr) print(unique_values) print(f"Количество вхождений каждого уникального числа: {counts}")
[[1 8 1 ... 6 3 0] [4 5 5 ... 6 4 9] [3 1 4 ... 2 5 8] ... [3 5 3 ... 0 7 7] [0 4 0 ... 8 5 4] [6 3 5 ... 0 2 2]] [0 1 2 3 4 5 6 7 8 9] Количество вхождений каждого уникального числа: [25119 25042 25089 25186 24868 24888 24926 24941 24854 25087]
import numpy as np arr = np.array([3, 12, 4, 1, 5, 9, 2, 6, 15, -4, 10, -2, 0, 11, 7]) # сортировка по возрастанию sorted_asc = np.sort(arr) # сортировка по убыванию sorted_des = np.sort(arr)[::-1] print(sorted_asc) print(sorted_des)
[-4 -2 0 1 2 3 4 5 6 7 9 10 11 12 15] [15 12 11 10 9 7 6 5 4 3 2 1 0 -2 -4]
import numpy as np # Создание двумерного массива arr = np.arange(16).reshape((4, 4)) print("Исходный массив:") print(arr) # Получение значения главной диагонали print("nГлавная диагональ массива:") print(np.diag(arr)) # Создание диагональной матрицы из указанных элементов diag_matrix = np.diag([1, 2, 3, 4, 5]) print("nДиагональная матрица:") print(diag_matrix)
Исходный массив: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]] Главная диагональ массива: [ 0 5 10 15] Диагональная матрица: [[1 0 0 0 0] [0 2 0 0 0] [0 0 3 0 0] [0 0 0 4 0] [0 0 0 0 5]]
import numpy as np # Создание двумерного массива arr = np.random.randint(0, 10, size=(20, 20)) print("Исходный массив:") print(arr) # Вычисление следа матрицы trace = np.trace(arr) print("След матрицы:") print(trace)
Исходный массив: [[0 2 9 3 8 9 6 5 4 8 2 1 9 6 0 5 9 1 4 8] [8 1 3 1 5 8 9 4 6 7 7 3 6 5 7 3 4 6 4 7] [4 4 9 2 8 3 1 0 9 1 7 6 6 3 5 5 3 8 5 2] [7 9 5 9 5 5 5 4 2 2 8 5 8 8 8 1 6 9 9 0] [5 3 8 2 3 2 6 7 8 5 2 9 7 4 7 8 3 2 8 0] [7 1 4 8 7 0 5 6 1 5 7 2 1 5 3 7 9 3 0 1] [9 9 1 5 3 2 9 5 4 3 2 1 9 5 5 3 5 1 0 7] [3 8 6 0 7 0 8 8 8 7 4 6 7 3 8 0 0 7 5 8] [3 5 5 7 6 1 0 6 3 8 0 9 7 1 3 4 1 8 3 4] [1 9 4 3 6 3 2 4 6 2 4 3 8 5 8 5 4 5 4 8] [5 4 2 0 9 8 1 3 8 0 9 1 6 9 4 2 0 8 3 4] [6 4 1 4 9 8 6 0 7 7 0 1 9 3 5 3 8 7 9 2] [9 4 9 2 5 2 8 6 0 9 0 6 4 1 7 0 6 4 2 8] [2 6 7 2 5 1 7 0 9 9 4 8 2 1 8 6 8 9 3 0] [1 8 3 8 2 6 3 0 0 0 4 0 1 4 2 4 3 2 8 9] [3 9 2 6 6 7 8 4 3 6 6 0 1 6 2 8 8 6 8 7] [6 2 1 3 0 1 6 5 7 6 8 6 4 5 3 9 3 1 3 2] [6 2 9 4 4 8 1 3 1 8 1 2 4 9 8 2 3 9 7 8] [1 2 8 7 4 6 9 5 4 9 3 9 2 8 3 8 1 8 2 3] [9 8 6 2 5 9 9 6 3 0 6 5 6 5 7 7 7 9 4 7]] След матрицы: 90 Интересные возможности NumPy
Эффективное хранение и быстрая загрузка данных
import numpy as np data = np.array([[1, 2, 3], [4, 5, 6]]) np.savetxt("data.txt", data, delimiter=",") data = np.loadtxt("data.txt", delimiter=",", dtype=np.int32) print(data)
import numpy as np data = np.array([[1, 2, 3], [4, 5, 6]]) np.save("data.npy", data) loaded_data = np.load("data.npy") print(loaded_data) Обработка изображений
import numpy as np from PIL import Image # загрузка изображения img = np.array(Image.open('image.jpeg')) # преобразование в черно-белое изображение img_gray = np.mean(img, axis=2).astype(np.uint8) # преобразование цветных каналов img_R = img.copy() img_R[:, :, (1, 2)] = 0 img_G = img.copy() img_G[:, :, (0, 2)] = 0 img_B = img.copy() img_B[:, :, (0, 1)] = 0 # объединение изображений img_1 = Image.fromarray(img_gray) img_2 = Image.fromarray(img_R) img_3 = Image.fromarray(img_G) img_4 = Image.fromarray(img_B) result = Image.new("RGB", (img.shape[1]*2, img.shape[0]*2)) result.paste(img_1, (0,0)) result.paste(img_2, (img.shape[1],0)) result.paste(img_3, (0,img.shape[0])) result.paste(img_4, (img.shape[1],img.shape[0])) result.save("result.png", format="PNG") Визуализация данных
import numpy as np import matplotlib.pyplot as plt # Загрузка данных из файла data = np.genfromtxt('litecoin.csv', delimiter=',', skip_header=1, usecols=(1, 2, 3, 4, 5, 6)) # Разделение данных на столбцы open_prices, high_prices, low_prices, close_prices, adj_close_prices, volumes = data.T # Создание графика цены закрытия plt.plot(close_prices) # Настройка осей plt.xlabel('Месяцы') plt.ylabel('Цена закрытия') plt.title('Стоимость Litecoin за период с июля 2018 по июнь 2023') # Установка значений на оси x n = len(close_prices) step = n // 10 plt.xticks(range(0, n, step)) # Отображение графика plt.show() Практика
Задание 1
Массив: [[5.72 2.78 4.21 5.61 1.26 9.61 2.87 7.08 4.86 9.71] [6.37 4.92 8.99 4.77 2.5 4.91 3.64 5.54 6.35 1.04] [1.63 4.35 8.56 4.86 2.32 1.77 9.76 4.52 5.09 4.05] [2.55 3.3 6.57 7.27 4.08 2.77 6.53 5.04 4.69 2.99] [7.65 5.2 7.27 5.48 3.38 1.9 1.68 4.87 4.81 9.96] [3.65 5.97 2.92 2.13 3.58 6.24 4.53 9.06 3.64 4.35] [4.95 1.84 2.98 1.98 1.47 7.65 2.09 3.01 2.2 2.71] [9.44 3.26 6.6 6.44 6.45 5.9 2.36 3.96 7.21 9.18] [3.23 3.12 7.19 6.69 6.9 8.4 7.67 3.71 1.93 6.07] [6.48 2.57 5.52 5.8 2.32 7.07 9.22 2.43 4.43 4.05]] Среднее значение: 4.90 Минимальный элемент: 1.04 Максимальный элемент: 9.96 Медиана: 4.79 Стандартное отклонение: 2.31 Дисперсия: 5.32 Диагональ: [5.72 4.92 8.56 7.27 3.38 6.24 2.09 3.96 1.93 4.05]
import numpy as np # генерация массива 10 на 10 случайных чисел в интервале от 1.01 до 9.99 arr = np.random.uniform(low=1.01, high=9.99, size=(10,10)) # округление элементов массива до 2 знаков arr = np.around(arr, decimals=2) # вывод массива print(f"Массив: n{arr}") # вывод статистической информации print(f"nСреднее значение: {arr.mean():.2f}") print(f"Минимальный элемент: {np.min(arr):.2f}") print(f"Максимальный элемент: {np.max(arr):.2f}") print(f"Медиана: {np.median(arr):.2f}") print(f"Стандартное отклонение: {np.std(arr):.2f}") print(f"Дисперсия: {np.var(arr):.2f}") # вывод диагонали массива print(f"nДиагональ: n{np.diag(arr)}") Задание 2
Самый прибыльный сезон - лето
import numpy as np # Данные о прокате велосипедов за каждый месяц сезона spring_rentals = np.array([11362, 11489, 12842]) summer_rentals = np.array([15401, 16562, 17728]) autumn_rentals = np.array([14994, 13851, 12784]) winter_rentals = np.array([840, 950, 1210]) # Вычисление общего количества прокатов велосипедов для каждого сезона total_spring_rentals = np.sum(spring_rentals) total_summer_rentals = np.sum(summer_rentals) total_autumn_rentals = np.sum(autumn_rentals) total_winter_rentals = np.sum(winter_rentals) # Вычисление среднего количества прокатов велосипедов для каждого сезона average_spring_rentals = np.mean(spring_rentals) average_summer_rentals = np.mean(summer_rentals) average_autumn_rentals = np.mean(autumn_rentals) average_winter_rentals = np.mean(winter_rentals) # Создание массива средних значений average_rentals = np.array([average_spring_rentals, average_summer_rentals, average_autumn_rentals, average_winter_rentals]) # Определение самого прибыльного сезона most_profitable_season = np.argmax(average_rentals) seasons = ['весна', 'лето', 'осень', 'зима'] print(f"Самый прибыльный сезон - {seasons[most_profitable_season]}") Задание 3
[ # Январь, Февраль, Март, Апрель, Май, Июнь, Июль, Август, Сентябрь, Октябрь, Ноябрь, Декабрь [1000, 1200, 1500, 1350, 1400, 1300, 1250, 1450, 1300, 1550, 1600, 1700], # Завод 1 [800, 900, 1000, 950, 1000, 1100, 1200, 1150, 1000, 1100, 1200, 1300], # Завод 2 [1200, 1300, 1250, 1400, 1500, 1600, 1650, 1700, 1600, 1550, 1500, 1400], # Завод 3 [900, 950, 1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350, 1400, 1450], # Завод 4 ]
Общее количество произведенных грузовиков за год: 61050 Завод 1 - 16600 грузовиков Завод 2 - 12700 грузовиков Завод 3 - 17650 грузовиков Завод 4 - 14100 грузовиков Завод 3 был самым продуктивным
import numpy as np # Создание массива данных о производстве production_data = np.array([ # Январь, Февраль, Март, Апрель, Май, Июнь, Июль, Август, Сентябрь, Октябрь, Ноябрь, Декабрь [1000, 1200, 1500, 1350, 1400, 1300, 1250, 1450, 1300, 1550, 1600, 1700], # Завод 1 [800, 900, 1000, 950, 1000, 1100, 1200, 1150, 1000, 1100, 1200, 1300], # Завод 2 [1200, 1300, 1250, 1400, 1500, 1600, 1650, 1700, 1600, 1550, 1500, 1400], # Завод 3 [900, 950, 1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350, 1400, 1450], # Завод 4 ]) # Подсчет общего количества произведенных грузовиков за год total_production = np.sum(production_data) # Подсчет количества произведенных грузовиков на каждом заводе за год total_production_by_factory = np.sum(production_data, axis=1) # Определение завода, на котором было произведено больше всего грузовиков за год most_productive_factory = np.argmax(total_production_by_factory) + 1 # Вывод общего количества произведенных грузовиков за год print(f"Общее количество произведенных грузовиков за год: {total_production}") # Вывод количества произведенных грузовиков на каждом заводе за год for i, count in enumerate(total_production_by_factory): print(f"Завод {i+1} - {count} грузовиков") # Вывод завода, на котором было произведено больше всего грузовиков за год print(f"Завод {most_productive_factory} был самым продуктивным") Задание 4
production_plan = np.array([ [110, 120, 80, 100, 200, 200, 100, 90, 150, 100, 205, 100], [90, 110, 70, 110, 180, 200, 120, 80, 150, 100, 205, 110], [80, 70, 90, 90, 150, 105, 105, 70, 90, 80, 105, 85], [120, 140, 100, 120, 230, 100, 110, 80, 70, 90, 205, 110], [130, 150, 110, 110, 240, 100, 110, 80, 75, 90, 205, 100], [140, 160, 120, 110, 250, 100, 100, 80, 75, 90, 205, 120], [150, 170, 130, 90, 260, 100, 100, 80, 80, 100, 205, 200], [160, 180, 140, 120, 270, 100, 120, 80, 85, 100, 205, 210], [170, 190, 150, 120, 280, 100, 130, 80, 90, 120, 205, 210], [180, 200, 160, 130, 290, 100, 140, 80, 95, 130, 205, 220], [190, 210, 170, 140, 300, 100, 130, 80, 150, 140, 205, 230], [200, 220, 180, 150, 310, 100, 160, 80, 150, 200, 205, 250] ]) prices_per_ton = np.array([10000, 150000, 12000, 80000, 2000, 33060, 5000, 10000, 170000, 19000, 8600, 7000])
Больше всего затрат приходится на: Торт "Клубничный" Меньше всего средств тратится на: Пряники "Изюм" Месяц с минимальными затратами на сырье: март Месяц с максимальными затратами на сырье: декабрь
import numpy as np # Годовой план производства (в тоннах) production_plan = np.array([ [110, 120, 80, 100, 200, 200, 100, 90, 150, 100, 205, 100], [90, 110, 70, 110, 180, 200, 120, 80, 150, 100, 205, 110], [80, 70, 90, 90, 150, 105, 105, 70, 90, 80, 105, 85], [120, 140, 100, 120, 230, 100, 110, 80, 70, 90, 205, 110], [130, 150, 110, 110, 240, 100, 110, 80, 75, 90, 205, 100], [140, 160, 120, 110, 250, 100, 100, 80, 75, 90, 205, 120], [150, 170, 130, 90, 260, 100, 100, 80, 80, 100, 205, 200], [160, 180, 140, 120, 270, 100, 120, 80, 85, 100, 205, 210], [170, 190, 150, 120, 280, 100, 130, 80, 90, 120, 205, 210], [180, 200, 160, 130, 290, 100, 140, 80, 95, 130, 205, 220], [190, 210, 170, 140, 300, 100, 130, 80, 150, 140, 205, 230], [200, 220, 180, 150, 310, 100, 160, 80, 150, 200, 205, 250] ]) # Цены на сырье (за тонну) prices_per_ton = np.array([10000, 150000, 12000, 80000, 2000, 33060, 5000, 10000, 170000, 19000, 8600, 7000]) # Вычисление объемов закупок сырья для каждого месяца и вида продукции monthly_purchases = np.dot(production_plan, np.diag(prices_per_ton)) # Вычисление общей стоимости ежемесячных закупок сырья total_costs = np.sum(monthly_purchases, axis=1) months = ['январь', 'февраль', 'март', 'апрель', 'май', 'июнь', 'июль', 'август', 'сентябрь', 'октябрь', 'ноябрь', 'декабрь'] # Виды продукции products = np.array(['Печенье "Чебурашка"', 'Торт "Клубничный"', 'Конфеты "Птичка"', 'Шоколад "Золотой стандарт"', 'Пряники "Изюм"', 'Зефир "Бриз"', 'Пирожное "Тирамису"', 'Мармелад "Fruit&Berry"', 'Мусс "Крем-брюле"', 'Брауни "Ореховый"', 'Кекс "Праздник"', 'Батончики "Сюрприз"']) # Названия ингредиентов ingredients = np.array(['Мука', 'Сахар', 'Масло', 'Какао', 'Мед', 'Ваниль', 'Яйца', 'Кондитерская глазурь', 'Фрукты', 'Орехи', 'Кокосовая стружка', 'Сливки']) # Суммарная стоимость по каждому виду продукции product_costs = np.sum(monthly_purchases, axis=0) # Виды продукции, на которые приходятся максимум и минимум затрат most_expenses_index = np.argmax(product_costs) least_expenses_index = np.argmin(product_costs) # Индексы месяцев с минимальными и максимальными затратами на сырье min_month_index = np.argmin(total_costs) max_month_index = np.argmax(total_costs) print(f"Больше всего затрат приходится на: {products[most_expenses_index]}") print(f"Меньше всего средств тратится на: {products[least_expenses_index]}") print(f"Месяц с минимальными затратами на сырье: {months[min_month_index]}") print(f"Месяц с максимальными затратами на сырье: {months[max_month_index]}") Задание 5
Прошлая доходность акций 10, 5, 15, 8, 12 Стандартное отклонение акций 2, 3, 4, 2.5, 3.5 Сумма 1000000 Допустимый уровень риска 10 Доли акций в портфеле 0.2, 0.3, 0.15, 0.25, 0.1
Уровень риска портфеля соответствует требованиям.
import numpy as np print("Прошлая доходность акций") # Прошлая доходность акций (в процентах за период) returns = np.array([float(element) for element in input().split(",")]) print("Стандартное отклонение акций") # Стандартное отклонение акций (в процентах) std_devs = np.array([float(element) for element in input().split(",")]) print("Сумма") # Сумма, которой располагает инвестор invest_amount = int(input()) print("Допустимый уровень риска") # Допустимый уровень риска портфеля (в процентах) risk_level = int(input()) # Вычисление взвешенной средней доходности портфеля print("Доли акций в портфеле") weights = np.array([float(element) for element in input().split(",")]) portfolio_returns = np.dot(returns, weights) # Вычисление стандартного отклонения портфеля portfolio_std_dev = np.sqrt(np.dot(weights, np.dot(std_devs, weights.T))) # Проверка уровня риска портфеля if (portfolio_std_dev <= risk_level).any(): print("Уровень риска портфеля соответствует требованиям.") else: print("Уровень риска слишком высок. Рекомендуем изменить веса акций в портфеле.") Задание 6
2023-04-11 29653.679688 30509.083984 29609.300781 30235.058594 30235.058594 20121259843 2023-04-12 30231.582031 30462.480469 29725.574219 30139.052734 30139.052734 18651929926 2023-04-13 29892.740234 30539.845703 29878.623047 30399.066406 30399.066406 17487721001 2023-04-14 30409.562500 31005.607422 30044.498047 30485.699219 30485.699219 22659995079 2023-04-18 29449.091797 30470.302734 29154.849609 30397.552734 30397.552734 19480529496 2023-06-21 28311.310547 30737.330078 28283.410156 30027.296875 30027.296875 33346760979 2023-06-23 29896.382813 31389.539063 29845.214844 30695.468750 30695.468750 24115570085 2023-06-26 30480.523438 30636.029297 29955.744141 30271.130859 30271.130859 16493186997 2023-06-27 30274.320313 31006.787109 30236.650391 30688.164063 30688.164063 16428827944 2023-06-30 30446.085938 31238.339844 30363.273438 30821.589844 30821.589844 17436878848
import csv import numpy as np data = [] with open('BTC-USD.csv', 'r') as file: csv_reader = csv.reader(file) for row in csv_reader: data.append(row) header = data[0] close_prices_index = header.index('Close') volumes_index = header.index('Volume') close_prices = np.array([float(row[close_prices_index]) for row in data[1:]]) volumes = np.array([float(row[volumes_index]) for row in data[1:]]) threshold_price = 30000 threshold_volume = 16000000000 filtered_days = np.where((close_prices > threshold_price) & (volumes >= threshold_volume)) selected_days = [data[i+1] for i in filtered_days[0]] for day in selected_days: print(*day) Задание 7
Платеж Аннуитетный Дифференцированный #1 166071.55 188888.89 #2 166071.55 187500.0 #3 166071.55 186111.11 #4 166071.55 184722.22 #5 166071.55 183333.33 #6 166071.55 181944.44 #7 166071.55 180555.56 #8 166071.55 179166.67 #9 166071.55 177777.78 #10 166071.55 176388.89 #11 166071.55 175000.0 #12 166071.55 173611.11 #13 166071.55 172222.22 #14 166071.55 170833.33 #15 166071.55 169444.44 #16 166071.55 168055.56 #17 166071.55 166666.67 #18 166071.55 165277.78 #19 166071.55 163888.89 #20 166071.55 162500.0 #21 166071.55 161111.11 #22 166071.55 159722.22 #23 166071.55 158333.33 #24 166071.55 156944.44 #25 166071.55 155555.56 #26 166071.55 154166.67 #27 166071.55 152777.78 #28 166071.55 151388.89 #29 166071.55 150000.0 #30 166071.55 148611.11 #31 166071.55 147222.22 #32 166071.55 145833.33 #33 166071.55 144444.44 #34 166071.55 143055.56 #35 166071.55 141666.67 #36 166071.55 140277.78 Переплата при аннуитетном погашении: 978575.77 Переплата при дифференцированном погашении: 925000.0
import numpy_financial as npf import numpy as np # Заданные параметры кредита annual_interest_rate = 0.12 loan_amount = 5000000 loan_term = 3 # Расчет месячной процентной ставки и общего количества платежей monthly_interest_rate = annual_interest_rate / 12 total_payments = loan_term * 12 # Расчет аннуитетного платежа annuity_payment = npf.pmt(monthly_interest_rate, total_payments, -loan_amount) # Расчет дифференцированного платежа principal_payment = loan_amount / total_payments # Расчет оставшейся суммы кредита для каждого месяца remaining_loan_amounts = loan_amount - np.arange(total_payments) * principal_payment # Расчет процентных платежей interest_payments = remaining_loan_amounts * monthly_interest_rate # Расчет дифференцированных платежей differentiated_payments = principal_payment + interest_payments # Вывод заголовка таблицы print(f"{'Платеж':<10}{'Аннуитетный':<15}{'Дифференцированный':<15}") # Вывод строк таблицы для каждого платежа for i, payment in enumerate(differentiated_payments, 1): print(f"#{i:<9}{round(annuity_payment, 2):<15}{round(payment, 2):<15}") # Расчет общих затрат на погашение кредита для аннуитетного и дифференцированного способов total_cost_annuity = annuity_payment * total_payments total_cost_differentiated = sum(differentiated_payments) # Вывод общих затрат на погашение кредита print(f"nПереплата при аннуитетном погашении: {round(total_cost_annuity - loan_amount, 2)}") print(f"Переплата при дифференцированном погашении: {round(total_cost_differentiated - loan_amount, 2)}") Задание 8
Ускорение Максимальное ускорение: 6.2 Время достижения максимального ускорения: 6 Минимальное ускорение: 2.8 Время достижения минимального ускорения: 2 Сила Максимальная сила: 310 Время достижения максимальной силы: 4 Минимальная сила: 220 Время достижения минимальной силы: 2 Деформация Максимальная деформация: 0.05 Время достижения максимальной деформации: 6 Минимальная деформация: 0.01 Время достижения минимальной деформации: 2 Интегральные параметры Площадь под кривой ускорения: 34.0 Площадь под кривой силы: 2157.5 Статистика Среднее значение ускорения: 4.23 Стандартное отклонение ускорения: 0.95 Среднее значение силы: 268.89 Стандартное отклонение силы: 23.90
import numpy as np # Временные ряды acceleration = np.array([3.5, 4.2, 2.8, 3.5, 4.2, 5.1, 6.2, 3.9, 4.7]) force = np.array([250, 280, 220, 290, 310, 260, 265, 270, 275]) deformation = np.array([0.02, 0.03, 0.01, 0.02, 0.03, 0.04, 0.05, 0.03, 0.02]) # Нахождение максимальных и минимальных значений и времени достижения для каждого параметра max_acceleration = np.max(acceleration) min_acceleration = np.min(acceleration) time_of_max_acceleration = np.argmax(acceleration) time_of_min_acceleration = np.argmin(acceleration) max_force = np.max(force) min_force = np.min(force) time_of_max_force = np.argmax(force) time_of_min_force = np.argmin(force) max_deformation = np.max(deformation) min_deformation = np.min(deformation) time_of_max_deformation = np.argmax(deformation) time_of_min_deformation = np.argmin(deformation) # Вычисление площади под кривой ускорения и силы area_acceleration = np.trapz(acceleration) area_force = np.trapz(force) # Вычисление среднего значения и стандартного отклонения для ускорения и силы mean_acceleration = np.mean(acceleration) std_acceleration = np.std(acceleration) mean_force = np.mean(force) std_force = np.std(force) print("Ускорение") print("Максимальное ускорение:", max_acceleration) print("Время достижения максимального ускорения:", time_of_max_acceleration) print("Минимальное ускорение:", min_acceleration) print("Время достижения минимального ускорения:", time_of_min_acceleration) print("nСила") print("Максимальная сила:", max_force) print("Время достижения максимальной силы:", time_of_max_force) print("Минимальная сила:", min_force) print("Время достижения минимальной силы:", time_of_min_force) print("nДеформация") print("Максимальная деформация:", max_deformation) print("Время достижения максимальной деформации:", time_of_max_deformation) print("Минимальная деформация:", min_deformation) print("Время достижения минимальной деформации:", time_of_min_deformation) print("nИнтегральные параметры") print("Площадь под кривой ускорения:", area_acceleration) print("Площадь под кривой силы:", area_force) print("nСтатистика") print(f"Среднее значение ускорения: {mean_acceleration:.2f}") print(f"Стандартное отклонение ускорения: {std_acceleration:.2f}") print(f"Среднее значение силы: {mean_force:.2f}") print(f"Стандартное отклонение силы: {std_force:.2f}") Задание 9
10.07.23
11.07.23
12.07.23
13.07.23
14.07.23
Нижний Новгород
1000000
2000000
2500000
3000000
2150000
Астрахань
1560000
2330000
2500000
3990000
2150000
Самара
2120000
2500000
3770000
2650000
4000000
Москва
2589000
2990000
4488000
4586000
3500000
Воронеж
2100000
2599000
3100000
2110000
4233000
Санкт-Петербург
1533000
2660000
4220000
3500000
2577000
Город с наибольшей выручкой: Москва День с наибольшей выручкой: 13.07.23
import numpy as np revenue = np.array([[1000000, 2000000, 2500000, 3000000, 2150000], [1560000, 2330000, 2500000, 3990000, 2150000], [2120000, 2500000, 3770000, 2650000, 4000000], [2589000, 2990000, 4488000, 4586000, 3500000], [2100000, 2599000, 3100000, 2110000, 4233000], [1533000, 2660000, 4220000, 3500000, 2577000]]) cities = np.array(['Нижний Новгород', 'Астрахань', 'Самара', 'Москва', 'Воронеж', 'Санкт-Петербург']) days = np.array(['10.07.23', '11.07.23', '12.07.23', '13.07.23', '14.07.23']) # Находим город с наибольшей суммарной выручкой total_revenue = np.sum(revenue, axis=1) max_revenue_city = cities[np.argmax(total_revenue)] print('Город с наибольшей выручкой:', max_revenue_city) # Находим день с наибольшей выручкой max_revenue_day = days[np.argmax(np.max(revenue, axis=0))] print('День с наибольшей выручкой:', max_revenue_day) Задание 10
years = np.random.choice(range(2011, 2023), size=100000) sales = np.random.randint(500, 125000, size=100000) revenue = np.random.randint(1000000, 50000000, size=100000)
Общее количество продаж в 2011 году: 515147911 в 2012 году: 515179236 в 2013 году: 528064407 в 2014 году: 517416072 в 2015 году: 527501756 в 2016 году: 538125332 в 2017 году: 522721395 в 2018 году: 525814794 в 2019 году: 518083325 в 2020 году: 520183365 в 2021 году: 531273592 в 2022 году: 524972288 Средняя выручка в 2011 году: 25704926.10 в 2012 году: 25219581.33 в 2013 году: 25578527.41 в 2014 году: 25712459.61 в 2015 году: 25326597.70 в 2016 году: 25396822.60 в 2017 году: 25516990.28 в 2018 году: 25346759.66 в 2019 году: 25283882.80 в 2020 году: 25723706.84 в 2021 году: 25462308.43 в 2022 году: 25350071.26 Год с максимальным количеством продаж: 2017 Год с минимальной выручкой от продаж: 2019
import numpy as np # Генерация случайных данных о продажах years = np.random.choice(range(2011, 2023), size=100000) sales = np.random.randint(500, 125000, size=100000) revenue = np.random.randint(1000000, 50000000, size=100000) sales_data = np.column_stack((years, sales, revenue)) # Находим общее количество продаж за каждый год total_sales_by_year = np.zeros((12,)) for i in range(12): total_sales = np.sum(sales_data[sales_data[:, 0] == (2011 + i), 1]) total_sales_by_year[i] = total_sales print("Общее количество продаж") for i, year in enumerate(range(2011, 2023)): print(f"в {year} году: {int(total_sales_by_year[i])}") # Вычисляем среднюю выручку от продажи за каждый год average_revenue_by_year = np.zeros((12,)) for i in range(12): average_revenue = np.mean(sales_data[sales_data[:, 0] == (2011 + i), 2]) average_revenue_by_year[i] = average_revenue print("nСредняя выручка") for i, year in enumerate(range(2011, 2023)): print(f"в {year} году: {average_revenue_by_year[i]:.2f}") # Определяем год с максимальным количеством продаж max_sales_year = sales_data[:, 0][np.argmax(sales_data[:, 1])] print(f"nГод с максимальным количеством продаж: {max_sales_year}") # Определяем год с минимальной выручкой от продажи min_revenue_year = sales_data[:, 0][np.argmin(sales_data[:, 2])] print(f"Год с минимальной выручкой от продаж: {min_revenue_year}") Подведем итоги
Содержание самоучителя
- 0 views
- 0 Comment