Программирование в «Эврике»
Теперь мы можем присваивать каждому элементу списка A новое значение. Например, мы можем сделать элемент A[0] также равным списку:
A[0]=range[3]
Теперь A будет равно [[0, 1, 2], 1, 2, 3, 4] , то есть объект A[0] будет списком [0, 1, 2] . В свою очередь, мы можем обращаться к отдельным элементам списка A[0] : A[0][0]==0 , A[0][1]==1 , A[0][2]==2 .
На практике часто приходится иметь дело с прямоугольными таблицами данных, также называемых двумерными массивами. Их можно представлять в виде списка из n элементов (строк), каждый из которых является списком из m элементов (столбцов). Тогда к отдельному элементу двумерного массива A можн обращаться, как A[i][j] , где i является номером строки, 0
Итак, создадим массив A из n=3 строк и m=5 столбцов:
n=3 m=5 A=range(n) # A является списком из n строк for i in range(n): A[i]=range(m) # Каждая строка является списком из m элементов
Заполнение массива
Теперь заполним массив нулями. Для этого нам понадобится два вложенных цикла: внешний цикл по всем строкам, а внутренний – по всем столбцам.
for i in range(n): for j in range(m): A[i][j]=0
Если мы захотим записать в массив таблицу умножения, присвоив элементу A[i][j] значение i*j , последнюю строку в этом примере нужно записать в виде A[i][j]=i*j .
Вывод массива на экран
Конечно, можно вывести массив A на экран одной командой print A , но тогда все элементы будут выведены в одну строку:
[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]
Но можно вывести массив в виде таблицы, так, чтобы каждая строка массива была выведена на одной строке, а внутри строки числа разделялись одним пробелом, то есть в виде:
A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[1][0] A[1][1] A[1][2] A[1][3] A[1][4] A[2][0] A[2][1] A[2][2] A[2][3] A[2][4]
Для этого снова понадобятся два вложенных цикла. Один цикл по всем строкам, другой – по всем столбцам. В результате получаем:
for i in range(n): for j in range(m): print A[i][j], print
Обратите внимание на запятую, поставленную после инструкции print A[i][j] , необходимую для того, чтобы печать продолжалась на этой же строке. А вот инструкцию print без параметров для перехода на новую строку мы даем после завершения внутреннего цикла, то есть после вывода всей строки на экран. Вот что получится:
0 0 0 0 0 0 1 2 3 4 0 2 4 6 8
Считывание с клавиатуры
Теперь рассмотрим проблему считывания массива с клавиатуры в таком же виде. Проблема заключается в том, что функция input позволяет считать только одно значение, записанное в строке и выдаст ошибку при считывании набора чисел, разделенных пробелами. А функция raw_input сможет считать строку как единое целое вместе со всеми пробелами. Разбить строку на отдельные выражения, разделенные пробелами можно при помощи метода split() . Этот метод применяется к строке и возвращает список подстрок, состоящих из непробельных символов и разделенных пробелами. То есть если применить метод split к строке ‘1 2 3’ , то получится список из 3 строк: [‘1’, ‘2’, ‘3’] . Таким образом, мы можем разбить каждую входную строку на отдельные подстроки, а затем преобразовать эти подстроки к числовому виду при помощи функции int . В результате получаем следующий код (предполагается, что массив A из n строк и m столбцов уже создан):
for i in range(n): # Цикл по всем строкам s=raw_input() # Считали строку в переменную s s=s.split() # Разбили s на слова и записали их в виде списка for j in range(m): A[i][j]=int(s[j]) # Элементу A[i][j] присваиваем значение s[j]
Общий пример программы
Теперь объединим это все в одну программу, которая считывает с клавиатуры числа n и m (заданные в одной строке), затем создает массив из n строк и m столбцов, затем считывает его с клавиатуры построчно, затем увеличивает каждый элемент массива на 1, наконец, печатает результат:
# Считываем размеры массива s=raw_input() s=s.split() n=int(s[0]) m=int(s[1]) # Создаем массив A=range(n) for i in range(n): A[i]=range(m) # Считываем массив с клавиатуры for i in range(n): s=raw_input() s=s.split() for j in range(m): A[i][j]=int(s[j]) # Увеличиваем все элементы на 1 for i in range(n): for j in range(m): A[i][j]=A[i][j]+1 # Выводим массив на экран for i in range(n): for j in range(m): print A[i][j], print
Сложный пример обработки массива
Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали проходящей из левого верхнего угла в правый нижний (то есть тем элементам A[i][j] , для которых i==j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n==4 ):
1 0 0 0 2 1 0 0 2 2 1 0 2 2 2 1
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы A[i][j] , для которых ij . Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j] . Получаем следующий алгоритм:
for i in range(n): for j in range(n): if ij: A[i][j]=2 else: A[i][j]=1
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
for i in range(n): A[i][i]=1
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам A[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
for i in range(n): for j in range(i+1,n): A[i][j]=0
Аналогично присваиваем значение 2 элементам A[i][j] для j = 0 , . i-1 :
for i in range(n): for j in range(0,i): A[i][j]=2
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
for i in range(n): for j in range(0,i): A[i][j]=2 A[i][i]=1 for j in range(i+1,n): A[i][j]=0
Форматирование чисел при выводе
Допустим, мы заполним массив таблицей умножения: A[i][j]=i*j как в примере в начале раздела. Если мы теперь попробуем вывести этот массив на экран, разделяя элементы в строке одним пробелом, то из-за того, что числа имеют различную длину столбцы таблицы окажутся неровными:
0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 0 2 4 6 8 10 12 14 16 18 0 3 6 9 12 15 18 21 24 27
Для того, чтобы получить ровные столбцы необходимо, выводить числа так, чтобы одно выводимое число имело длину, например, ровно в 2 символа, а «лишние» позиции были бы заполнены пробелами.
0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 0 2 4 6 8 10 12 14 16 18 0 3 6 9 12 15 18 21 24 27
Без лишних комментариев покажем, как в программе указать, что целое число x нужно выводить так, чтобы оно занимало ровно две позиции: print «%2d» % x . Здесь, естественно, можно заменить значение x на то значение, которое необходимо напечатать, а число 2 на любую другую ширину поля.
Итак, для печати ровной таблицы умножения можно воспользоваться следующим кодом:
for i in range(n): for j in range(m): print «%2d» % A[i][j],
Двумерные массивы
Часто в задачах приходится хранить прямоугольные таблицы с данными. Такие таблицы называются матрицами или двумерными массивами. В языке программирования Питон таблицу можно представить в виде списка строк, каждый элемент которого является в свою очередь списком, например, чисел. Например, создать числовую таблицу из двух строк и трех столбцов можно так:
A = [ [1, 2, 3], [4, 5, 6] ]
Здесь первая строка списка A[0] является списком из чисел [1, 2, 3] . То есть A[0][0] == 1 , значение A[0][1] == 2 , A[0][2] == 3 , A[1][0] == 4 , A[1][1] == 5 , A[1][2] == 6 .
Для обработки и вывода списка как правило используется два вложенных цикла. Первый цикл по номеру строки, второй цикл по элементам внутри строки. Например, вывести двумерный числовой список на экран построчно, разделяя числа пробелами внутри одной строки, можно так:
for i in range(len(A)): for j in range(len(A[i]): print(A[i][j], end = ' ') print()
То же самое, но циклы не по индексу, а по значениям списка:
for row in A: for elem in row: print(elem, end = ' ') print()
Естественно для вывода одной строки можно воспользоваться методом join :
for row in A: print(' '.join(list(map(str, row))))
Используем два вложенных цикла для подсчета суммы всех чисел в списке:
S = 0 for i in range(len(A)): for j in range(len(A[i])): S += A[i][j]
Или то же самое с циклом не по индексу, а по значениям строк:
S = 0 for row in A: for elem in row: S += elem
Создание списка
Пусть даны два числа: количество строк n и количество столбцов m . Необходимо создать список размером n × m , заполненный нулями.
Очевидное решение оказывается неверным:
A = [ [0] * m ] * n
В этом легко убедиться, если присвоить элементу A[0][0] значение 1 , а потом вывести значение другого элемента A[1][0] — оно тоже будет равно 1! Дело в том, что [0] * m возвращает ccылку на список из m нулей. Но последующее повторение этого элемента создает список из n элементов, которые являются ссылкой на один и тот же список (точно так же, как выполнение операции B = A для списков не создает новый список), поэтому все строки результирующего списка на самом деле являются одной и той же строкой.
Таким образом, двумерный список нельзя создавать при помощи операции повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов (для начала просто из n нулей). Затем сделаем каждый элемент списка ссылкой на другой одномерный список из m элементов:
A = [0] * n for i in range(n): A[i] = [0] * m
Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:
A = [] for i in range(n): A.append([0] * m)
Ввод списка
Пусть программа получает на вход двумерный массив, в виде n строк, каждая из которых содержит m чисел, разделенных пробелами. Как их считать? Например, так:
A = [] for i in range(n): A.append(list(map(int, input().split())))
Или, без использования сложных вложенных вызовов функций:
A = [] for i in range(n): row = input().split() for i in range(len(row)): row[i] = int(row[i]) A.append(row)
Сложный пример обработки массива
Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам A[i][j] , для которых i==j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n==4 ):
1 0 0 0 2 1 0 0 2 2 1 0 2 2 2 1
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы A[i][j] , для которых ij . Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j] . Получаем следующий алгоритм:
for i in range(n): for j in range(n): if i < j: A[i][j] = 0 elif i >j: A[i][j] = 2 else: A[i][j] = 1
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
for i in range(n): A[i][i] = 1
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам A[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
for i in range(n): for j in range(i + 1, n): A[i][j] = 0
Аналогично присваиваем значение 2 элементам A[i][j] для j = 0 , . i-1 :
for i in range(n): for j in range(0, i): A[i][j] = 2
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
for i in range(n): for j in range(0, i): A[i][j] = 2 A[i][i] = 1 for j in range(i + 1, n): A[i][j] = 0
А вот такое решение использует операцию повторения списков для построения очередной строки списка. i -я строка списка состоит из i чисел 2 , затем идет одно число 1 , затем идет n-i-1 число 0 :
for i in range(n): A[i] = [2] * i + [1] + [0] * (n - i - 1)
Упражнения
A: Максимум
Найдите индексы первого вхождения максимального элемента. Выведите два числа: номер строки и номер столбца, в которых стоит наибольший элемент в двумерном массиве. Если таких элементов несколько, то выводится тот, у которого меньше номер строки, а если номера строк равны то тот, у которого меньше номер столбца.
3 4
0 3 2 4
2 3 5 5
5 1 2 3
Python Урок 8. Матрицы (двумерный массив)
Для работы с матрицами в Python также используются списки. Каждый элемент списка-матрицы содержит вложенный список.
Рассмотрим пример матрицы размера 4 х 3:
matrix = [[-1, 0, 1], [-1, 0, 1], [0, 1, -1], [1, 1, -1]]
matrix = [[-1, 0, 1], [-1, 0, 1], [0, 1, -1], [1, 1, -1]]
Данный оператор можно записать в одну строку:
matrix = [[-1, 0, 1], [-1, 0, 1], [0, 1, -1], [1, 1, -1]]
matrix = [[-1, 0, 1], [-1, 0, 1], [0, 1, -1], [1, 1, -1]]
print(matrix)
1 2 3 4 5
def printMatrix ( matrix ): for i in range ( len(matrix) ): for j in range ( len(matrix[i]) ): print ( "".format(matrix[i][j]), end = "" ) print ()
def printMatrix ( matrix ): for i in range ( len(matrix) ): for j in range ( len(matrix[i]) ): print ( «».format(matrix[i][j]), end = «» ) print ()
В примере i – это номер строки, а j – номер столбца;
len(matrix) – число строк в матрице.
1 2 3 4 5
def printMatrix ( matrix ): for row in matrix: for x in row: print ( "".format(x), end = "" ) print ()
def printMatrix ( matrix ): for row in matrix: for x in row: print ( «».format(x), end = «» ) print ()
1 2 3 4
from random import randint n, m = 3, 3 a = [[randint(1, 10) for j in range(m)] for i in range(n)] print(a)
from random import randint n, m = 3, 3 a = [[randint(1, 10) for j in range(m)] for i in range(n)] print(a)
Обработка элементов двумерного массива
Нумерация элементов двумерного массива, как и элементов одномерного массива, начинается с нуля.
Т.е. matrix[2][3] — это элемент третьей строки четвертого столбца.
Пример обработки элементов матрицы:
Найти произведение элементов двумерного массива.
1 2 3 4 5
p = 1 for i in range(N): for j in range(M): p *= matrix[i][j] print (p)
p = 1 for i in range(N): for j in range(M): p *= matrix[i][j] print (p)
Пример:
Найти сумму элементов двумерного массива.
Более подходящий вариант для Python:
1 2 3 4
s = 0 for row in matrix: s += sum(row) print (s)
s = 0 for row in matrix: s += sum(row) print (s)
Для поиска суммы существует стандартная функция sum.
Задание Python 8_0:
Получены значения температуры воздуха за 4 дня с трех метеостанций, расположенных в разных регионах страны:
| Номер станции | 1-й день | 2-й день | 3-й день | 4-й день |
|---|---|---|---|---|
| 1 | -8 | -14 | -19 | -18 |
| 2 | 25 | 28 | 26 | 20 |
| 3 | 11 | 18 | 20 | 25 |
Т.е. запись показаний в двумерном массиве выглядела бы так:
- Распечатать температуру на 2-й метеостанции за 4-й день и на 3-й метеостанции за 1-й день.
- Распечатать показания термометров всех метеостанций за 2-й день.
- Определить среднюю температуру на 3-й метеостанции.
- Распечатать, в какие дни и на каких метеостанциях температура была в диапазоне 24-26 градусов тепла.
Задание Python 8_1:
Написать программу поиска минимального и максимального элементов матрицы и их индексов.
Задание Python 8_2:
Написать программу, выводящую на экран строку матрицы, сумма элементов которой максимальна.
for i in range(N): # работаем с matrix[i][i]
for i in range(N): # работаем с matrix[i][i]
for i in range(N): # работаем с matrix[i][N-1-i]
for i in range(N): # работаем с matrix[i][N-1-i]
Пример:Переставить 2-й и 4-й столбцы матрицы. Использовать два способа.
for i in range(N): c = A[i][2] A[i][2] = A[i][4] A[i][4] = c
for i in range(N): c = A[i][2] A[i][2] = A[i][4] A[i][4] = c
for i in range(N): A[i][2], A[i][4] = A[i][4], A[i][2]
for i in range(N): A[i][2], A[i][4] = A[i][4], A[i][2]
Задание Python 8_3:
Составить программу, позволяющую с помощью датчика случайных чисел сформировать матрицу размерностью N. Определить:
Как определить сколько вхождений элемента в двумерный массив Python
Подскажите пожалуйста, как определить: Сколько вхождений каждого элемента по порядку во весь список b (т.е. сколько например элементов i или are во всем списке b)? К примеру, нижеуказанный код очевидно неверный, т.к. он покажет только вхождение элемента i[0] во весь список (а нужно всех элементов), но еще интересует, почему выдается результат 0 вхождений, несмотря на то, что i[0] — это в нашем списке является i, а ее в общем списке 2 штуки.
for i in b: print(b.count(i[0])) Пришлось преобразовывать двумерный список b в общий список и потом перебором без проблем все сделал, но понимаю, что это слабовато, т.к. приходится делать лишние движения с преобразованием списков, поэтому хочу узнать, как это можно сделать с исходным списком. При ответе учтите пожалуйста, что мой уровень начальный и ответ должен быть соответствующий, либо ответ может быть любой (для последующего изучения мной материала на эту тему), но с дублированием простого.