Двумерные массивы (матрицы)

Создание, обход по строкам и столбцам, суммирование элементов, транспонирование матрицы

Понятие двумерного массива

Двумерный массив (матрица) — это таблица данных, элементы которой расположены в строках и столбцах и определяются двумя индексами: номером строки и номером столбца. Матрицы используют для хранения табличных данных: изображений (яркость пикселей), игровых полей, таблиц оценок нескольких учеников по нескольким предметам и т.д. В Python двумерный массив обычно представляют как список списков: внешний список хранит строки, а каждая строка сама является списком чисел (столбцов).

Размер матрицы: число строк и столбцов

Число строк матрицы a в Python вычисляется как len(a) — это длина внешнего списка. Число столбцов определяется длиной одной из строк, например len(a[0]) — при условии, что все строки матрицы имеют одинаковую длину (такую матрицу называют прямоугольной, в отличие от «рваной», в которой строки могут содержать разное число элементов). На практике почти все задачи имеют дело именно с прямоугольными матрицами, и перед обработкой полезно явно вывести или проверить её размеры.

a = [

[1, 2, 3, 4],

[5, 6, 7, 8],

[9, 10, 11, 12]

]

rows = len(a)

cols = len(a[0])

print(f'Матрица размером {rows}x{cols}')

# Проверка, что матрица действительно прямоугольная

is_rectangular = all(len(row) == cols for row in a)

print('Прямоугольная:', is_rectangular)

Индексация элементов матрицы

Если матрица a имеет m строк и n столбцов, то к элементу, стоящему на пересечении строки i и столбца j, обращаются записью a[i][j], где i — номер строки (первый индекс), j — номер столбца (второй индекс). Нумерация строк и столбцов, как и в одномерном массиве, начинается с нуля.

$0\le i\le m-1,0\le j\le n-1$

Создание и заполнение матрицы

Матрицу размером m×n можно задать явным перечислением строк либо сгенерировать с помощью вложенного генератора списков. Важно не создавать матрицу конструкцией [[0] * n] * m: в этом случае все m строк оказываются ссылками на один и тот же список, и изменение одного элемента затронет сразу все строки — это одна из самых коварных ошибок начинающих.

# Явное задание матрицы 3×4

a = [

[1, 2, 3, 4],

[5, 6, 7, 8],

[9, 10, 11, 12]

]

# ОШИБКА: все строки — один и тот же объект

wrong = [[0] * 4] * 3

wrong[0][0] = 99

print(wrong) # изменились ВСЕ строки!

# ПРАВИЛЬНО: вложенный генератор списков

m, n = 3, 4

correct = [[0] * n for _ in range(m)]

correct[0][0] = 99

print(correct) # изменилась только первая строка

# Заполнение случайными числами

import random

b = [[random.randint(1, 9) for _ in range(n)] for _ in range(m)]

print(b)

Ввод матрицы с клавиатуры

Матрицу обычно вводят построчно: сначала считывают число строк m и число столбцов n, а затем m раз считывают строку чисел через пробел.

m, n = map(int, input().split())

a = []

for i in range(m):

row = list(map(int, input().split()))

a.append(row)

print(a)

Обход матрицы по строкам и столбцам

Для перебора всех элементов матрицы используют два вложенных цикла: внешний цикл идёт по строкам (индекс i), внутренний — по столбцам (индекс j). Такой порядок обхода называют обходом «по строкам». Если нужно обойти матрицу «по столбцам», циклы можно поменять местами: внешний — по j, внутренний — по i.

a = [

[1, 2, 3],

[4, 5, 6],

[7, 8, 9]

]

m, n = len(a), len(a[0])

# Обход по строкам (сначала первая строка целиком, потом вторая…)

for i in range(m):

for j in range(n):

print(a[i][j], end=' ')

print()

# Обход по столбцам (сначала первый столбец целиком, потом второй…)

for j in range(n):

for i in range(m):

print(a[i][j], end=' ')

print()

Суммирование элементов матрицы

Сумма всех элементов матрицы вычисляется так же, как и для одномерного массива, — накоплением при полном переборе всех m·n элементов с помощью двух вложенных циклов.

$S=\Sigma \Sigma a\left[i\right]\left[j\right],гдеi=0...m-1,j=0...n-1$

a = [

[1, 2, 3],

[4, 5, 6],

[7, 8, 9]

]

total = 0

for i in range(len(a)):

for j in range(len(a[i])):

total += a[i][j]

print('Сумма всех элементов:', total)

# Сумма каждой строки

for i in range(len(a)):

print(f'Сумма строки {i}:', sum(a[i]))

# Сумма каждого столбца

n = len(a[0])

for j in range(n):

col_sum = 0

for i in range(len(a)):

col_sum += a[i][j]

print(f'Сумма столбца {j}:', col_sum)

Поиск максимального элемента и его координат

Поиск максимума в матрице устроен так же, как в одномерном массиве, только теперь для позиции элемента нужно хранить сразу два индекса — номер строки и номер столбца.

a = [

[1, 12, 3],

[4, 5, 6],

[7, 8, 9]

]

max_value = a[0][0]

max_i, max_j = 0, 0

for i in range(len(a)):

for j in range(len(a[i])):

if a[i][j] > max_value:

max_value = a[i][j]

max_i, max_j = i, j

print(f'Максимум {max_value} находится в строке {max_i}, столбце {max_j}')

Сумма элементов диагоналей

Для квадратной матрицы размером n×n отдельный интерес представляют элементы главной диагонали (индексы строки и столбца совпадают: a[i][i]) и элементы побочной диагонали (сумма индексов постоянна и равна n−1: a[i][n-1-i]).

$главнаядиагональ:i=j;побочнаядиагональ:i+j=n-1$

a = [

[1, 2, 3],

[4, 5, 6],

[7, 8, 9]

]

n = len(a)

main_diag_sum = 0

side_diag_sum = 0

for i in range(n):

main_diag_sum += a[i][i]

side_diag_sum += a[i][n — 1 — i]

print('Сумма главной диагонали:', main_diag_sum)

print('Сумма побочной диагонали:', side_diag_sum)

Применение матриц: игровое поле и таблица данных

Двумерные массивы естественно моделируют множество реальных объектов: игровое поле в задачах про крестики-нолики или морской бой (клетка (i, j) хранит своё состояние — пусто, крестик, нолик, корабль), шахматную доску, экран из пикселей (яркость каждого пикселя — элемент матрицы) или, например, таблицу оценок нескольких учеников по нескольким предметам, где строка соответствует ученику, а столбец — предмету. В последнем случае для получения среднего балла конкретного ученика достаточно найти среднее его строки, а для среднего балла по конкретному предмету — среднее соответствующего столбца, что напрямую использует уже рассмотренные приёмы обхода матрицы по строкам и по столбцам.

# Таблица оценок: строки — ученики, столбцы — предметы

grades = [

[5, 4, 5], # ученик 0

[3, 4, 4], # ученик 1

[5, 5, 5] # ученик 2

]

# Средний балл каждого ученика (среднее по строке)

for i, row in enumerate(grades):

print(f'Ученик {i}: средний балл {sum(row) / len(row):.2f}')

# Средний балл по каждому предмету (среднее по столбцу)

n = len(grades[0])

for j in range(n):

col = [grades[i][j] for i in range(len(grades))]

print(f'Предмет {j}: средний балл {sum(col) / len(col):.2f}')

Проверка на симметричность квадратной матрицы

Квадратная матрица называется симметричной, если она совпадает со своей транспонированной версией, то есть a[i][j] = a[j][i] для любых i и j. Симметричные матрицы часто встречаются в задачах, где хранится, например, таблица расстояний между городами или таблица взаимодействий: расстояние от города A до города B совпадает с расстоянием от B до A.

def is_symmetric(a):

n = len(a)

for i in range(n):

for j in range(n):

if a[i][j] != a[j][i]:

return False

return True

m1 = [[0, 3, 5], [3, 0, 7], [5, 7, 0]]

m2 = [[0, 3, 5], [4, 0, 7], [5, 7, 0]]

print(is_symmetric(m1)) # True

print(is_symmetric(m2)) # False

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

Транспонирование матрицы — это операция, при которой строки становятся столбцами, а столбцы — строками: элемент, стоявший на месте (i, j), переходит на место (j, i). Если исходная матрица имела размер m×n, то транспонированная будет иметь размер n×m.

$aᵀ\left[j\right]\left[i\right]=a\left[i\right]\left[j\right]$

a = [

[1, 2, 3],

[4, 5, 6]

]

m, n = len(a), len(a[0])

# Транспонирование вручную

b = [[0] * m for _ in range(n)]

for i in range(m):

for j in range(n):

b[j][i] = a[i][j]

for row in b:

print(row)

# Транспонирование с помощью zip

b2 = [list(row) for row in zip(*a)]

print(b2)

Типичные ошибки

Самая опасная ошибка при работе с матрицами — создание строк конструкцией [[0] * n] * m, при которой все строки ссылаются на один и тот же список в памяти. Также часто путают порядок индексов: a[i][j] означает «строка i, столбец j», а не наоборот, и при вводе матрицы важно не перепутать местами число строк m и число столбцов n. Ещё одна распространённая ошибка — использовать len(a) там, где нужна длина конкретной строки len(a[i]) (это критично для «рваных» матриц с разной длиной строк), и наоборот. Наконец, при переборе по столбцам легко перепутать внешний и внутренний циклы, что не приводит к ошибке выполнения, но меняет порядок обработки элементов.

Краткий словарь терминов

Матрица (двумерный массив) — таблица данных, элементы которой определяются двумя индексами — номером строки и номером столбца.

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

Главная диагональ — элементы матрицы, у которых номер строки равен номеру столбца (i = j).

Побочная диагональ — элементы матрицы, у которых сумма номера строки и номера столбца постоянна и равна n−1.

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

Вложенный цикл — цикл внутри другого цикла; используется для обхода всех элементов двумерного массива.

Заключение

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