В Python, как и с двумерными массивами, нет встроенного типа данных "матрица" в том же смысле, как в математике или в языках, вроде MATLAB. Однако есть два основных и наиболее распространенных способа работы с матрицами:
Списки списков (List of Lists): Самый простой и базовый способ, используя стандартные типы данных Python. Подходит для небольших матриц или когда вы не выполняете много математических операций. NumPy (Numerical Python): Это де-факто стандартная библиотека для работы с матрицами и многомерными массивами в Python, особенно для научных вычислений, обработки данных и машинного обучения. Она обеспечивает высокую производительность и множество встроенных функций для матричных операций.
Давайте рассмотрим оба подхода.
Библиотека NumPy предоставляет объект ndarray (N-мерный массив), который является идеальной структурой данных для матриц в Python. Она оптимизирована для числовых вычислений на больших объемах данных.
Установка NumPy:
Если у вас еще нет NumPy, установите его:
Bash
Pip install numpy
Создание матриц NumPy:
Python
Import numpy as np
# Создание из списка списков
Np_matrix_a = np. array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
Np_matrix_b = np. array([
[10, 11, 12],
[13, 14, 15]
])
Print("\n--- Матрицы с помощью NumPy ---")
Print("NumPy Matrix A:")
Print(np_matrix_a)
Print("\nNumPy Matrix B:")
Print(np_matrix_b)
# Создание матриц специального вида
Zeros_matrix = np. zeros((2, 3)) # Матрица 2x3 из нулей
Print(f"\nМатрица нулей (2x3):\n{zeros_matrix}")
Ones_matrix = np. ones((3, 2)) # Матрица 3x2 из единиц
Print(f"\nМатрица единиц (3x2):\n{ones_matrix}")
Identity_matrix = np. eye(3) # Единичная матрица 3x3
Print(f"\nЕдиничная матрица (3x3):\n{identity_matrix}")
# Создание случайной матрицы
Random_matrix = np. random. rand(2, 2) # Матрица 2x2 случайных чисел от 0 до 1
Print(f"\nСлучайная матрица (2x2):\n{random_matrix}")
Доступ к элементам и срезы:
Индексирование в NumPy более гибкое. Можно использовать [строка, столбец] или [строка][столбец].
Python
Print(f"\nЭлемент в np_matrix_a[0, 0]: {np_matrix_a[0, 0]}") # 1
Print(f"Элемент в np_matrix_a[1, 2]: {np_matrix_a[1, 2]}") # 6
# Срезы строк/столбцов
Print(f"\nПервая строка np_matrix_a: {np_matrix_a[0, :]}") # или np_matrix_a[0]
Print(f"Второй столбец np_matrix_a: {np_matrix_a[:, 1]}")
Print(f"Подматрица np_matrix_a (первые 2 строки, первые 2 столбца):\n{np_matrix_a[0:2, 0:2]}")
Размеры (форма) матрицы:
Атрибут. shape возвращает кортеж с размерами матрицы.
Python
Print(f"\nФорма np_matrix_a: {np_matrix_a. shape}") # (3, 3)
Print(f"Форма np_matrix_b: {np_matrix_b. shape}") # (2, 3)
Матричные операции (главное преимущество NumPy):
NumPy перегружает операторы Python для интуитивно понятных матричных операций.
- Поэлементное сложение/вычитание/умножение/деление: Используйте стандартные операторы +, -, *, /. Матричное умножение: Используйте оператор @ (Python 3.5+) или метод. dot(). Транспонирование: Используйте метод. T или функцию np. transpose().
Python
Np_matrix_c = np. array([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
# Поэлементное сложение
Sum_np_matrix = np_matrix_a + np_matrix_c
Print(f"\nПоэлементное сложение (np_matrix_a + np_matrix_c):\n{sum_np_matrix}")
# Поэлементное умножение (не матричное!)
Elementwise_mult = np_matrix_a * np_matrix_c
Print(f"\nПоэлементное умножение (np_matrix_a * np_matrix_c):\n{elementwise_mult}")
# Матричное умножение (np_matrix_a @ np_matrix_a)
Matrix_mult = np_matrix_a @ np. array([[1], [2], [3]]) # Умножение 3x3 на 3x1
Print(f"\nМатричное умножение (np_matrix_a @ [1,2,3]T):\n{matrix_mult}")
# Транспонирование
Transposed_np_a = np_matrix_a. T
Print(f"\nТранспонированная np_matrix_a:\n{transposed_np_a}")
# Инверсия матрицы (только для квадратных невырожденных матриц)
Try:
inverse_matrix_a = np. linalg. inv(np_matrix_a)
print(f"\nИнверсия np_matrix_a:\n{inverse_matrix_a}")
Except np. linalg. LinAlgError:
print("\nМатрица не является обратимой.")
# Определитель матрицы
Print(f"\nОпределитель np_matrix_a: {np. linalg. det(np_matrix_a)}")
Вывод:
Для Любых серьезных задач, связанных с матрицами в Python (будь то линейная алгебра, машинное обучение, обработка изображений, научные расчеты), Используйте NumPy. Он предоставляет мощные, эффективные и удобные инструменты для работы с многомерными массивами и матрицами.
Списки списков подходят только для очень простых, небольших задач, где производительность некритична, и вы не выполняете сложных матричных операций.
Это, по сути, двумерный массив, где каждый внутренний список представляет собой строку матрицы.
Создание матрицы:
Python
# Матрица 3x3
Matrix_a = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Матрица 2x3
Matrix_b = [
[10, 11, 12],
[13, 14, 15]
]
Print("Матрица A:")
For row in matrix_a:
print(row)
Print("\nМатрица B:")
For row in matrix_b:
print(row)
Доступ к элементам:
Доступ осуществляется по индексам [строка][столбец].
Python
Print(f"\nЭлемент в matrix_a[0][0]: {matrix_a[0][0]}") # 1
Print(f"Элемент в matrix_a[1][2]: {matrix_a[1][2]}") # 6
Получение размеров (количества строк и столбцов):
Python
Rows_a = len(matrix_a)
Cols_a = len(matrix_a[0]) # Предполагаем, что все строки имеют одинаковую длину
Print(f"\nРазмеры matrix_a: {rows_a} строки, {cols_a} столбца") # 3 строки, 3 столбца
Базовые операции (вручную):
Для сложения, умножения и транспонирования придется писать функции.
Python
# Сложение матриц (должны быть одинакового размера)
Def add_matrices(mat1, mat2):
if len(mat1) != len(mat2) or len(mat1[0]) != len(mat2[0]):
raise ValueError("Матрицы должны быть одинакового размера для сложения")
rows = len(mat1)
cols = len(mat1[0])
result = [[0 for _ in range(cols)] for _ in range(rows)]
for i in range(rows):
for j in range(cols):
result[i][j] = mat1[i][j] + mat2[i][j]
return result
Matrix_c = [
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
] # Единичная матрица
Try:
sum_matrix = add_matrices(matrix_a, matrix_c)
print("\nСумма matrix_a и matrix_c:")
for row in sum_matrix:
print(row)
Except ValueError as e:
print(f"Ошибка: {e}")
# Транспонирование матрицы
Def transpose_matrix(mat):
rows = len(mat)
cols = len(mat[0])
result = [[0 for _ in range(rows)] for _ in range(cols)] # Меняем rows и cols местами
for i in range(rows):
for j in range(cols):
result[j][i] = mat[i][j]
return result
Transposed_a = transpose_matrix(matrix_a)
Print("\nТранспонированная matrix_a:")
For row in transposed_a:
print(row)
Transposed_b = transpose_matrix(matrix_b)
Print("\nТранспонированная matrix_b (2x3 -> 3x2):")
For row in transposed_b:
print(row)
Ограничения списков списков для матриц:
- Неэффективность: Для больших матриц операции со списками списков медленные, так как Python-списки — это коллекции ссылок на объекты, а не непрерывные блоки памяти. Сложность операций: Приходится вручную реализовывать сложение, умножение, транспонирование и другие матричные операции, что ведет к громоздкому и потенциально ошибочному коду. Отсутствие встроенных функций: Нет готовых функций для линейной алгебры (определители, инверсия, собственные значения и т. д.).