NumPy — массивы и матрицы

НЕ ОБЯЗАТЕЛЬНО ДЛЯ НОВИЧКОВ

Приветствую! Здесь вы наверняка найдете, что ищете. Примеры в лаборатории рассчитаны на то, что мы разбираем что-то конкретное.

Текущая статья посвящена numPy на Python.array, среднее, матрица, linspace, axis, broadcasting; готовые примеры с разбором каждой строки и выводом программы..

Поэтому за теорией по текущей теме вам — в энциклопедию. Если ещё не погружались, то маршрут прост:

  1. Основы
  2. Система и сеть
  3. Данные и разметка
  4. Код и разработка
  5. Языки
  6. Искусственный интеллект
  7. Проект
  8. Инфраструктура и безопасность
  9. Спин-офф

Обязательно пройдитесь.

А теперь приступим к нашему предмету.

Теория и соседние материалы

Анализ данных — pandas, NumPy, SciPy

NumPy — теория (337)

Python для анализа данных

Matplotlib — графики (теория)

Pandas — типовые операции

Matplotlib — графики.

Основы числовых массивов на Python

NumPy — библиотека для быстрых вычислений с числами в Python. Обычный список [1, 2, 3] удобен для хранения, но медленный для математики на тысячах значений. NumPy хранит числа плотным блоком в памяти и считает сумму, среднее, sin, умножение матриц без цикла for — одной командой.

Ситуация Список Python NumPy
Средний балл класса sum(a)/len(a) вручную np.mean(a)
Сложить два столбца оценок цикл или list comprehension a + b
Таблица 3×3 для алгебры список списков np.array([[..]])
Ось X для графика sin for + append np.linspace + np.sin
Лабораторная по физике Excel или калькулятор массив измерений + статистика

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

С чего начать

Теория — Анализ данных и научные вычисления.

Таблица функций — Python для анализа данных.

Таблицы с именами столбцов — Pandas (после NumPy).

Графики — Matplotlib.

Формулы в буквах (корни, производные) — SymPy.

Здесь — числа и массивы: создать, посчитать, отфильтровать, умножить матрицы.

Навигация по примерам

Ищут в интернете Раздел ниже
numpy array python пример Создание массива
numpy создать массив из списка Создание массива
numpy 2d array / двумерный массив Создание массива
numpy mean average среднее Обязательный шаблон
numpy sum min max Агрегаты
numpy axis 0 axis 1 что значит Агрегаты — axis
numpy linspace vs arange Сетка для графика
numpy reshape transpose Форма и reshape
numpy indexing slice 2d Индексация
numpy filter array by condition Булева маска
numpy add arrays element wise Векторизация
numpy broadcasting example Broadcasting
numpy matrix multiplication dot Матрицы
numpy solve linear system Решение системы
numpy vs python list Список и NumPy
numpy random randint seed Случайные числа

Как запустить пример

Шаг 1. Установите NumPy (один раз):

pip install numpy

Разбор:

  • pip — установщик пакетов; идёт вместе с Python на Windows и macOS.
  • install numpy — скачивает библиотеку с PyPI; нужен интернет только в момент установки.
  • Если pip не найден — переустановите Python с python.org с галочкой «Add Python to PATH» или откройте Google Colab — там NumPy уже установлен.

Шаг 2. Скопируйте любой блок кода ниже в файл, например massivy.py.

Шаг 3. Запустите в терминале:

python massivy.py

Разбор:

  • python — интерпретатор; на Windows иногда py massivy.py.
  • Результат — текст в чёрном окне; NumPy не открывает графическое окно (для графиков нужен Matplotlib).

Шаг 4. В Jupyter или Colab — вставьте код в ячейку и нажмите Shift+Enter. Последняя строка ячейки может быть просто a или scores — таблица/массив отобразится красиво без print().

Базовые термины

Термин Простыми словами Аналог
ndarray Массив чисел одного типа; 1D, 2D, 3D… Столбец чисел или таблица без текста
shape Размеры: (5,) — пять чисел; (2, 3) — 2 строки × 3 столбца «сколько строк и столбцов»
dtype Тип ячеек: int64, float64 формат числа в Excel
axis=0 «Сжать строки» → итог по столбцам Среднее по каждому предмету
axis=1 «Сжать столбцы» → итог по строкам Средний балл каждого ученика
view Срез смотрит на те же данные в памяти Изменили копию формулы — изменился лист
broadcasting Короткий массив «растягивается» под длинный Прибавить 5 ко всем ячейкам
np.dot / @ Скалярное или матричное умножение u·v, A×B из алгебры

Мнемоника для axis: представьте таблицу оценок. axis=0 — столбец «падает» вниз, остаётся одна строка чисел (среднее по предметам). axis=1 — строка «сжимается» вправо (среднее по ученику).

Какую операцию выбрать

Задача Что использовать Пример одной строки
Список оценок → массив np.array np.array([5, 4, 3])
Пустая таблица n×m zeros, ones np.zeros((3, 4))
Числа 0, 2, 4 … arange np.arange(0, 10, 2)
100 точек от 0 до 10 (график) linspace np.linspace(0, 10, 100)
Среднее, сумма, мин, макс mean, sum, … np.mean(a)
Среднее по столбцам/строкам + axis np.mean(m, axis=0)
Умножение матриц @ A @ B
Только оценки ≥ 4 булева маска a[a >= 4]
Решить 2 уравнения с 2 неизвестными linalg.solve см. ниже

Список Python и NumPy — в чём разница

Зачем: почти каждый новичок спрашивает «зачем NumPy, если есть list». Этот блок — короткий ответ с кодом, который можно вставить в реферат или сказать на защите лабораторной.

Разбор:

  • 1_000_000 — миллион элементов; подчёркивание в числе для читаемости, Python его игнорирует (то же, что 1000000).
  • list(range(n)) — обычный список целых; каждый элемент — объект Python в памяти.
  • np.arange(n) — массив NumPy; числа лежат плотно, операции выполняются на C/Fortran под капотом.
  • [a + 1 for a in py_list] — list comprehension: цикл на Python, миллион итераций интерпретатора.
  • np_arr + 1 — векторизация: одна команда «прибавь 1 ко всем»; на больших данных NumPy обычно в десятки раз быстрее.
  • time.perf_counter() — засекает время; в учебной работе достаточно сказать «NumPy быстрее на больших массивах».
  • np_sum[:5] — первые пять элементов результата: [1 2 3 4 5].

Важно для ЕГЭ/олимпиадки: на 10–20 числах разницы почти нет; NumPy нужен, когда данных много (физика, статистика, ML) или когда пишете одну формулу вместо цикла.

Школьный вариант: уменьшите n до 100 — оба способа мгновенные, но идея «список = цикл, NumPy = формула» останется.

Обязательные элементы

Любой скрипт с NumPy — как рецепт: импорт → массив → операция → print. Запомните каркас; дальше меняете только середину.


import numpy as np

# 1. Массив из списка оценок
scores = np.array([5, 4, 5, 3, 4])

# 2. Операция — средний балл
average = np.mean(scores)

# 3. Вывод
print("Оценки:", scores)
print("Средний балл:", round(average, 2))
print("Сколько оценок:", scores.size)

Разбор:

  • import numpy as np — подключаем библиотеку один раз в начале файла. np — стандартное сокращение во всех учебниках и на Stack Overflow; дальше пишем np.array, а не numpy.array.
  • np.array([5, 4, 5, 3, 4]) — превращает список Python в объект ndarray. Все элементы одного типа (здесь целые → int64). Смешать строку и число в одном массиве можно, но тогда тип станет object и скорость пропадёт.
  • scores — имя переменной; в примерах часто a, x, data, arr — смысл тот же.
  • np.mean(scores) — среднее арифметическое: (5+4+5+3+4)/5 = 4.2. Без ручного sum/len и без цикла for.
  • round(average, 2) — округление до двух знаков после запятой; 4.2 уже красиво, но для дробных средних (4.333…) нужно.
  • scores.size — сколько элементов в массиве (5); для 2D смотрите scores.shape.
  • Первый print покажет Оценки: [5 4 5 3 4] — без запятых между числами, так печатает NumPy.

Что увидите в консоли:

Оценки: [5 4 5 3 4]
Средний балл: 4.2
Сколько оценок: 5

Школьный вариант: подставьте оценки своего класса. Добавьте пятёрку: np.array([.., 5]) — среднее пересчитается само.

Альтернатива без NumPy: sum(scores)/len(scores) работает и для списка; NumPy выигрывает, когда оценок сотни и нужны ещё std, median, фильтры.

Типичные ошибки новичков
  • [1,2,3] + [4,5,6] → [1,2,3,4,5,6] (склейка). np.array([1,2,3]) + np.array([4,5,6]) → [5,7,9] (сложение).
  • Срез b = a[1:] и b[0]=99 меняет и a — нужен .copy().
  • np.mean(matrix) без axis — одно число по всей таблице; для среднего по столбцам — axis=0.
  • Длины массивов при a + b должны совпадать, иначе ValueError.
  • Забыли import numpy as np → NameError: name 'np' is not defined.

Стартовые операции

Шесть блоков из первой лабораторной по данным и физике. Каждый — отдельный маленький файл: скопировали целиком → запустили → сверили вывод.

Создание массива из списка и конструкторы

Зачем: прежде чем считать среднее или умножать матрицы, нужен ndarray. Источник — список из программы, файла или «заготовка» из нулей/единиц под будущие расчёты.

Разбор:

  • np.array([10, 20, 30]) — одна ось, три числа. shape → (3,) — кортеж из одного числа 3; запятая после 3 обязательна в Python.
  • a.ndim — число осей: 1 для вектора, 2 для таблицы, 3 для «куба» данных.
  • [[1, 2, 3], [4, 5, 6]] — два внутренних списка = две строки. Столбцы: 1 и 4, 2 и 5, 3 и 6. shape → (2, 3).
  • dtype — тип элементов; целые → int64, дробные → float64. От типа зависят память и точность.
  • np.zeros((2, 3)) — аргумент кортеж формы (строки, столбцы); все ячейки 0.0 (float по умолчанию).
  • np.ones((3, 2)) — таблица из единиц; удобно как множитель «заполнить всё единицами перед формулой».
  • np.eye(3) — единичная матрица 3×3: единицы на главной диагонали, остальное 0. В алгебре — нейтральный элемент умножения.

Что увидите: eye — диагональ из единиц; zeros — прямоугольник нулей.

Школьный вариант: np.array([5, 4, 3, 5, 4]) — оценки за контрольную; дальше np.mean, np.max.

Из CSV позже: сначала Pandas читает файл, затем df["score"].to_numpy() даёт массив для NumPy.

arange и linspace — последовательности и сетка для графика

Зачем: для графика y = sin(x) нужны много точек X с равным шагом. range() даёт только целые; linspace — дробные и включает правую границу.

Разбор:

  • np.arange(0, 10, 2) — как range(0, 10, 2), но возвращает массив, не итератор. Три аргумента: start, stop (не включается), step.
  • np.linspace(0, 1, num=5) — stop включается. NumPy сам считает шаг: (1-0)/(5-1)=0.25. Удобно, когда нужно задать число точек, а не шаг.
  • 2 * np.pi — один полный оборот в радианах (≈6.28); период sin/cos.
  • num=100 — сто точек на отрезке; линия на графике будет гладкой.
  • np.sin(x) — синус каждого элемента x сразу; результат — массив той же длины 100.
  • x[0], x[-1] — первый и последний элемент; y[25] — примерно середина периода.
Вопрос arange linspace
Задаёте шаг число точек
Правая граница обычно не входит входит
Дробный шаг да да (автоматически)
Типичное use индексы 0…99 ось графика

Дальше: plt.plot(x, y) — Matplotlib, синусоида.

Частая ошибка: np.arange(0, 1, 0.1) из‑за округления float иногда не даёт ровно 1.0 в конце; для графиков надёжнее linspace(0, 1, 11).

Форма, reshape и транспонирование

Зачем: датчик отдал 12 чисел подряд — их нужно разложить в таблицу 3×4 для отчёта. Транспонирование — поменять строки и столбцы местами (как «транспонировать» в Excel).


import numpy as np

flat = np.arange(12)
print("Плоский 1D:", flat)

matrix = flat.reshape(3, 4)
print("\n3×4:\n", matrix)

transposed = matrix.T
print("\nТранспонированная 4×3:\n", transposed)
print("shape было", matrix.shape, "→ стало", transposed.shape)

Разбор:

  • np.arange(12) — числа 0, 1, …, 11 в одной строке.
  • .reshape(3, 4) — новая форма без копирования данных (если возможно): читает 12 чисел по строкам:
    • строка 0: 0,1,2,3
    • строка 1: 4,5,6,7
    • строка 2: 8,9,10,11
  • Произведение размеров должно совпасть: 3*4=12. Иначе ValueError.
  • .T — transpose: строки ↔ столбцы. Было (3,4) → (4,3). Элемент [i,j] становится [j,i].
  • np.transpose(matrix) — то же, что .T.

Школьный вариант: reshape(3, 3) из arange(9) — таблица умножения можно получить через np.outer (см. ниже).

Осторожно: reshape часто возвращает view; если потом менять элементы, исходный flat тоже изменится. Нужна копия — matrix = flat.reshape(3, 4).copy().

Индексация, срезы и булева маска

Зачем: взять третью оценку, второй столбец матрицы или все температуры выше нуля — без for.

Разбор:

  • Индексация с нуля: a[0] — первый элемент (10). a[-1] — последний (50); -1 = «с конца».
  • a[1:4] — от индекса 1 включительно до 4 не включая → элементы 20, 30, 40. Правило как у списков Python.
  • m[1, 2] — строка 1, столбец 2 → число 6 (не путать с «1-я строка в тетради» — в коде это индекс 1 = вторая строка).
  • m[0, :] — строка 0, все столбцы (: = «весь диапазон»).
  • m[:, 1] — второй столбец (индекс 1) из всех строк → [2, 5, 8].
  • temperatures > 0 — поэлементное сравнение → [False, False, True, True, False].
  • temperatures[mask] — оставить только True → [12, 25]. Это фильтр без цикла; в Pandas тот же приём: df[df["score"] >= 4].

Школьный вариант: scores[scores >= 4] — все четвёрки и пятёрки.

Альтернатива: np.where(temperatures > 0, temperatures, 0) — заменить холодные на 0, не отбрасывая длины массива.

Векторизация — арифметика без циклов

Зачем: сложить два столбца измерений, возвести в квадрат, перевести Fahrenheit → Celsius — одной формулой на весь массив.


import numpy as np

a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print("a + b:", a + b)
print("a * 2:", a * 2)
print("a ** 2:", a ** 2)

fahrenheit = np.array([32, 68, 100, 212])
celsius = (fahrenheit - 32) * 5 / 9
print("\n°F:", fahrenheit)
print("°C:", np.round(celsius, 1))

Разбор:

  • a + b — поэлементно: 1+10, 2+20, 3+30 → [11, 22, 33]. Длины должны совпадать.
  • a * 2 — умножить каждый элемент на 2; скаляр 2 «размазывается» на массив (broadcasting).
  • a ** 2 — квадрат каждого: [1, 4, 9]. Степень работает поэлементно.
  • (fahrenheit - 32) * 5 / 9 — школьная формула перевода температуры; скобки задают порядок: сначала −32, потом ×5/9.
  • 212 °F → 100 °C (кипение воды) — проверка, что формула верна.
  • np.round(celsius, 1) — один знак после запятой для красивого вывода.

Физика: массив скоростей v, кинетическая энергия 0.5 * m * v**2 — m скаляр, v**2 поэлементно.

Ошибка: [1,2,3] + [10,20,30,40] в NumPy даст ошибку; списки разной длины склеиваются только оператором + у list.

Broadcasting — матрица плюс вектор

Зачем: таблица цен 2 магазина × 3 товара; скидка по каждому товару одна — применить ко всем строкам без цикла.


import numpy as np

prices = np.array([[100, 200, 300],
                   [150, 250, 350]])
discount = np.array([10, 20, 30])

after = prices - discount
print("Цена − скидка:\n", after)

with_tax = after * 1.2
print("\n+20% НДС:\n", np.round(with_tax, 2))

Разбор:

  • prices — форма (2, 3): две строки (магазины), три столбца (товары).
  • discount — форма (3,): три скидки по столбцам.
  • NumPy виртуально повторяет [10,20,30] для каждой строки prices и вычитает → первая строка: 90, 180, 270; вторая: 140, 230, 330.
  • * 1.2 — скаляр ко всем ячейкам (+20%).
  • Broadcasting экономит память: реального «размножения» строк часто не происходит.

Школьный вариант: матрица оценок минус «штраф за опоздание» [0, 0, 1] — минус 1 балл только за третий предмет.

Когда ломается: формы (2,3) и (2,) не broadcast без reshape — NumPy выдаст ошибку; нужно понимать размерности.

Агрегаты — sum, mean, min, max и axis

Зачем: «средний балл по классу», «средний по каждому предмету», «сумма продаж по месяцам» — одна функция + правильный axis.


import numpy as np

grades = np.array([[5, 4, 5],   # ученик 0
                   [3, 4, 4],   # ученик 1
                   [5, 5, 3]])  # ученик 2
print("Среднее по всей таблице:", np.mean(grades))
print("По предметам (столбцы, axis=0):", np.mean(grades, axis=0))
print("По ученикам (строки, axis=1):", np.mean(grades, axis=1))
print("Сумма по предметам:", np.sum(grades, axis=0))
print("Лучшая оценка у каждого:", np.max(grades, axis=1))

Разбор:

  • grades — 3 строки × 3 столбца = 9 оценок.
  • np.mean(grades) без axis — одно число: сумма всех 9 оценок / 9.
  • axis=0 — сжать строки → для каждого столбца своё среднее:
    • предмет 0: (5+3+5)/3 = 4.33…
    • предмет 1: (4+4+5)/3 = 4.33…
    • предмет 2: (5+4+3)/3 = 4.0
  • axis=1 — «сжать столбцы» → средний балл ученика (три числа).
  • np.sum(.., axis=0) — сумма по столбцам (сколько баллов набрал класс по каждому предмету).
  • np.max(.., axis=1) — максимум в каждой строке (лучшая оценка ученика).

Как запомнить axis: axis=0 — стрелка вниз по столбцам ↓; axis=1 — вправо по строкам →.

Функция Без axis axis=0 axis=1
np.mean одно среднее по столбцам по строкам
np.sum общая сумма сумма столбца сумма строки
np.std разброс всего разброс по предметам разброс по ученикам

Школьный вариант: замените числа на журнал; axis=1 — кто «отличник» по среднему.

Excel: axis=0 ≈ формула СРЗНАЧ по столбцу; axis=1 — по строке.

Матрицы — dot, @ и скалярное произведение

Зачем: курс линейной алгебры — скалярное произведение векторов, умножение матриц 2×2, проверка «A×B ≠ B×A».

Разбор:

  • np.dot(u, v) для 1D массивов — скалярное произведение: одно число 32.
  • A @ B — матричное умножение: строка A на столбец B. Размер (2,2) @ (2,2) → (2,2).
  • Элемент C[0,0] = 1*5 + 2*7 = 19 — первая строка A на первый столбец B.
  • B @ A — другой результат; умножение не коммутативно (как в алгебре).
  • Оператор @ появился в Python 3.5; старый стиль — np.dot(A, B) для 2D.

Проверка размеров: (m,n) @ (n,p) → (m,p). Внутренние размеры n должны совпасть.

Физика: скалярное произведение силы и перемещения → работа, если векторы 1D.

Примеры для практики

1. Школьные задачи

1.1. Средний балл, медиана, разброс

Зачем: контрольная по информатике или статистике — «найти среднее, медиану, минимум» по списку оценок.


import numpy as np

scores = np.array([5, 4, 3, 5, 4, 5, 2, 4, 5, 3])
print("Оценки:", scores)
print("Среднее:", np.mean(scores))
print("Медиана:", np.median(scores))
print("Мин / макс:", np.min(scores), np.max(scores))
print("Стд. отклонение:", round(np.std(scores), 2))
print("Сколько пятёрок:", np.sum(scores == 5))

Разбор:

  • np.median — медиана: серединное значение после сортировки; устойчива к одной «двойке» среди пятёрок.
  • np.std — стандартное отклонение; показывает, насколько оценки «разбросаны» вокруг среднего.
  • scores == 5 — массив [True, False, …]; np.sum(..) считает True как 1 → число пятёрок.
  • round(.., 2) — два знака после запятой в отчёте.

Что увидите: среднее около 4.0; медиана 4.0 или 4.5 в зависимости от чётности; sum(scores==5) — 4 пятёрки.

Школьный вариант: вставьте оценки своего класса из журнала.

1.2. Таблица умножения через outer

Зачем: наглядно показать 2D-массив; частый мини-проект «таблица Пифагора на Python».


import numpy as np

n = np.arange(1, 10)
table = np.outer(n, n)
print("Таблица 9×9:\n", table)
print("3×7 =", table[2, 6])   # строка 3, столбец 7 → индексы 2 и 6

Разбор:

  • np.arange(1, 10) — числа 1…9.
  • np.outer(n, n) — матрица, где ячейка [i,j] = n[i] * n[j] → классическая таблица умножения.
  • table[2, 6] — строка с индексом 2 (число 3), столбец 6 (число 7) → 21.
  • table.shape → (9, 9).

Школьный вариант: np.arange(1, 11) — таблица до 10×10.

1.3. Нормализация оценок к шкале 0–100

Зачем: сравнить двух учеников из разных шкал (2–5 и 0–100) — min-max приведение к процентам.


import numpy as np

scores = np.array([2, 3, 4, 5, 5], dtype=float)
lo, hi = scores.min scores.max()
normalized = (scores - lo) / (hi - lo) * 100
print("Было (2–5):", scores)
print("Стало (0–100):", normalized)

Разбор:

  • dtype=float — деление не целочисленное; иначе (5-2)/(5-2) могло бы дать 1 вместо 1.0.
  • (scores - lo) / (hi - lo) — каждая оценка: «насколько далеко от минимума относительно диапазона».
  • * 100 — перевод в проценты; двойка → 0%, пятёрка → 100%.
  • Если все оценки одинаковы (hi == lo), деление на ноль → nan; в реальных данных проверяйте.

2. Матрицы и линейная алгебра

2.1. Решение системы 2×2

Зачем: пара линейных уравнений из алгебры — проверить ответ или не считать вручную определитель.


import numpy as np

# 2x + y = 5
# x + 3y = 6
A = np.array([[2, 1],
              [1, 3]], dtype=float)
b = np.array([5, 6], dtype=float)

solution = np.linalg.solve(A, b)
print("x, y =", solution)
print("Проверка A @ x =", A @ solution)

Разбор:

  • A — матрица коэффициентов при x и y; b — правые части.
  • np.linalg.solve(A, b) — решает Ax = b методами линейной алгебры; возвращает массив [x, y].
  • A @ solution — подставили найденные x, y; должно получиться [5, 6] (с погрешностью float ~1e-15).
  • dtype=float — дробные корни не теряются.

Школьный вариант: подставьте коэффициенты из задачника; сверьте с ответом в конце книги.

SymPy даёт точную дробь; NumPy — числа float. Для отчёта с √2 — SymPy.

2.2. След и диагональ


import numpy as np

m = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
print("diagonal:", np.diagonal(m))
print("trace (сумма диагонали):", np.trace(m))

Разбор:

  • np.diagonal(m) — элементы главной диагонали [1, 5, 9].
  • np.trace(m) — их сумма 15; для квадратных матриц часто встречается в теории.

3. Случайные числа

3.1. Имитация бросков кубика

Зачем: задачи вероятности — «100 бросков, сколько шестёрок»; фиксированный seed — одинаковый результат у всех в классе.


import numpy as np

rng = np.random.default_rng(42)
dice = rng.integers(1, 7, size=20)
print("20 бросков:", dice)
print("Среднее (ожидаем ~3.5):", round(np.mean(dice), 2))
print("Шестёрок:", np.sum(dice == 6))

Разбор:

  • default_rng(42) — современный генератор (NumPy 1.17+); 42 — seed для воспроизводимости.
  • integers(1, 7, size=20) — целые от 1 до 6 включительно (верхняя граница 7 не входит), 20 бросков.
  • np.mean(dice) — среднее близко к 3.5 при большом числе бросков.
  • np.sum(dice == 6) — сколько раз выпала 6.

Старый стиль: np.random.seed(42); np.random.randint(1, 7, 20) — тот же смысл, но в новых проектах лучше default_rng.

4. Связь с Pandas и Matplotlib

4.1. NumPy → Pandas


import numpy as np
import pandas as pd

names = ["Аня", "Боря", "Вера"]
scores = np.array([5, 4, 5])
df = pd.DataFrame({"name": names, "score": scores})
print(df)
print("Среднее (NumPy):", np.mean(df["score"].to_numpy()))

Разбор:

  • Имена — список строк; оценки — NumPy (числа).
  • pd.DataFrame({..}) — таблица; подробнее — Pandas.
  • .to_numpy() — столбец Pandas обратно в ndarray для np.mean / np.std.

4.2. NumPy → график параболы


import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 200)
y = x ** 2

plt.plot(x, y, label="y = x²")
plt.xlabel("x")
plt.ylabel("y")
plt.title("Парабола")
plt.grid(True, alpha=0.3)
plt.legend()
plt.show()

Разбор:

  • linspace(-5, 5, 200) — гладкая парабола; 200 точек достаточно для отчёта.
  • x ** 2 — векторизация; без NumPy нужен [i**2 for i in x].
  • plt.show() — окно графика; в Colab график под ячейкой.

Больше типов графиков — Matplotlib — примеры.

5. Переиспользуемые шаблоны

5.1. Мини-отчёт по столбцам


import numpy as np

def column_stats(matrix: np.ndarray) -> dict:
    return {
        "mean": np.mean(matrix, axis=0),
        "std": np.std(matrix, axis=0),
        "min": np.min(matrix, axis=0),
        "max": np.max(matrix, axis=0),
    }

data = np.array([[1, 10], [2, 20], [3, 30]])
for name, values in column_stats(data).items():
    print(name, values)

Разбор:

  • Функция принимает 2D-массив; возвращает словарь из четырёх векторов (по одному числу на столбец).
  • data — три измерения, два столбца; mean по axis=0 → [2, 20].
  • Можно вставить в лабораторную как «автоматический расчёт статистики по сериям опытов».

5.2. Безопасная копия среза


import numpy as np

original = np.array([1, 2, 3, 4, 5])
bad = original[2:]      # view — опасно
safe = original[2:].copy()

safe[0] = 99
print("original:", original)   # [1 2 3 4 5] — не изменился
print("safe:", safe)           # [99 4 5]

Разбор:

  • original[2:] — элементы с индекса 2: [3,4,5]; view на ту же память.
  • .copy() — отдельный массив; правка safe не трогает original.
  • Типичный баг лабораторных: «почему исходные данные испортились» — забыли .copy().
NumPy, Pandas, Matplotlib — порядок изучения
1. NumPy — числа и матрицы (эта страница).
2. Pandas — таблицы с именами столбцов, CSV, groupby.
3. Matplotlib — графики по массивам и таблицам.

Формулы в буквах (не числа) — SymPy.

Практикум: класс Vector и матрицы

Связано с Векторы и Матрицы. Теория NumPy — 337.

Класс Vector (полное решение)


import math

class Vector:
    def __init__(self, components) -> None:
        self.components = list(components)

    def __str__(self) -> str:
        return f"Vector: {self.components}"

    def __add__(self, other):
        if len(self.components) != len(other.components):
            raise ValueError("Векторы должны быть одинаковой длины")
        return Vector([i + j for i, j in zip(self.components, other.components)])

    def __sub__(self, other):
        if len(self.components) != len(other.components):
            raise ValueError("Векторы должны быть одинаковой длины")
        return Vector([i - j for i, j in zip(self.components, other.components)])

    def __mul__(self, scalar):
        return Vector([i * scalar for i in self.components])

    def dot_product(self, other):
        if len(self.components) != len(other.components):
            raise ValueError("Векторы должны быть одинаковой длины")
        return sum(i * j for i, j in zip(self.components, other.components))

    def length(self):
        return math.sqrt(sum(c * c for c in self.components))


v1 = Vector([4, 1])
v2 = Vector([2, 5])
print(v1 + v2)              # Vector: [6, 6]
print(v1.dot_product(v2))   # 13
print(v1.length())          # ≈4.12

Единичная матрица 9×9 циклом


import numpy as np

n = 9
I = np.zeros((n, n), dtype=int)
for i in range(n):
    I[i, i] = 1
print(I)

Суммы диагоналей


import numpy as np

M = np.array([
    [2,  1,  0,  4,  1],
    [0,  3,  5, -1,  2],
    [1,  0,  4,  2,  0],
    [3,  2,  1,  5,  1],
    [0,  1,  2,  0,  6],
])
main = np.trace(M)
anti = np.trace(np.fliplr(M))
print("главная:", main, "побочная:", anti)  # 20, 3

См. также