Как создать двумерный массив в python
Здесь первая строка списка 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 в Питоне может перебирать не только диапазон, создаваемый с помощью функции range() , но и вообще перебирать любые элементы любой последовательности. Последовательностями в Питоне являются списки, строки, а также некоторые другие объекты, с которыми мы пока не встречались. Продемонстрируем, как выводить двумерный массив, используя это удобное свойство цикла for :
Естественно, для вывода одной строки можно воспользоваться методом join() :
Используем два вложенных цикла для подсчета суммы всех чисел в списке:
Или то же самое с циклом не по индексу, а по значениям строк:
2. Создание вложенных списков
Пусть даны два числа: количество строк n и количество столбцов m . Необходимо создать список размером n × m , заполненный нулями.
Очевидное решение оказывается неверным:
В этом легко убедиться, если присвоить элементу a[0][0] значение 5 , а потом вывести значение другого элемента a[1][0] — оно тоже будет равно 5. Дело в том, что [0] * m возвращает ccылку на список из m нулей. Но последующее повторение этого элемента создает список из n элементов, которые являются ссылкой на один и тот же список (точно так же, как выполнение операции b = a для списков не создает новый список), поэтому все строки результирующего списка на самом деле являются одной и той же строкой.
В визуализаторе обратите внимание на номер id у списков. Если у двух списков id совпадает, то это на самом деле один и тот же список в памяти.
Таким образом, двумерный список нельзя создавать при помощи операции повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов (для начала просто из n нулей). Затем сделаем каждый элемент списка ссылкой на другой одномерный список из m элементов:
Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:
Но еще проще воспользоваться генератором: создать список из n элементов, каждый из которых будет списком, состоящих из m нулей:
В этом случае каждый элемент создается независимо от остальных (заново конструируется список [0] * m для заполнения очередного элемента списка), а не копируются ссылки на один и тот же список.
3. Ввод двумерного массива
Пусть программа получает на вход двумерный массив в виде n строк, каждая из которых содержит m чисел, разделенных пробелами. Как их считать? Например, так:
Или, без использования сложных вложенных вызовов функций:
Можно сделать то же самое и при помощи генератора:
4. Пример обработки двумерного массива
Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам a[i][j] , для которых i==j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть необходимо получить такой массив (пример для n==4 ):
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы a[i][j] , для которых i<j , а для элементов ниже главной диагонали i>j . Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j] . Получаем следующий алгоритм:
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам a[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
Аналогично присваиваем значение 2 элементам a[i][j] для j = 0 , . i-1 :
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
А вот такое решение использует операцию повторения списков для построения очередной строки списка. i -я строка списка состоит из i чисел 2 , затем идет одно число 1 , затем идет n-i-1 число 0 :
А можно заменить цикл на генератор:
5. Вложенные генераторы двумерных массивов
Для создания двумерных массивов можно использовать вложенные генераторы, разместив генератор списка, являющегося строкой, внутри генератора всех строк. Напомним, что сделать список из n строк и m столбцов можно при помощи генератора, создающего список из n элементов, каждый элемент которого является списком из m нулей:
Но при этом внутренний список также можно создать при помощи, например, такого генератора: [0 for j in range(m)] . Вложив один генератор в другой, получим вложенные генераторы:
Но если число 0 заменить на некоторое выражение, зависящее от i (номер строки) и j (номер столбца), то можно получить список, заполненный по некоторой формуле.
Например, пусть нужно задать следующий массив (для удобства добавлены дополнительные пробелы между элементами):
В этом массиве n = 5 строк, m = 6 столбцов, и элемент в строке i и столбце j вычисляется по формуле: a[i][j] = i * j .
Lesson 9
Двумерные списки (массивы)
1. Вложенные списки: обработка и печать
Первый элемент a здесь — 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-loop в Python может выполнять итерацию не только по range() , но обычно по всем элементам любой последовательности. Последовательности в Python — это списки и строки (и некоторые другие объекты, которые мы еще не встретили). Посмотрите, как вы можете печатать двумерный массив, используя эту удобную функцию цикла for :
Естественно, для вывода одной строки вы можете использовать метод join() :
Так вы можете использовать 2 вложенных цикла для вычисления суммы всех чисел в двумерном списке:
Или то же самое с итерацией элементами, а не переменными i и j :
2. Вложенные списки: создание
Предположим, что указаны два числа: число строк n и количество столбцов m . Вы должны создать список размером n × m , заполненный, скажем, нулями.
Очевидное решение кажется неправильным:
Это можно легко увидеть, если вы установите значение a[0][0] на 5 , а затем распечатаете значение a[1][0] — оно также будет равно 5. Причина в том, что [0] * m возвращает только ссылку на список из m нулей, но не список. Последующее повторение этого элемента создает список из n элементов, все ссылки на один и тот же список (как и операция b = a для списков не создает новый список), поэтому все строки в результирующем списке на самом деле одинаковы строка.
Используя наш визуализатор, отслеживайте идентификатор списков. Если два списка имеют одинаковый номер id, это фактически тот же список в памяти.
Таким образом, двумерный список не может быть создан просто путем повторения строки. Что делать.
Возможный способ: вы можете создать список из n элементов (например, из n нулей), а затем сделать каждый из элементов ссылкой на другой одномерный список из m элементов:
Другой (но похожий) способ: создать пустой список, а затем append к нему новый элемент n раз (этот элемент должен быть списком длины m ):
Но самый простой способ — использовать генератор, создавая список из n элементов, каждый из которых представляет собой список из m нулей:
В этом случае каждый элемент создается независимо от других. Список [0] * m n раз помечается как новый, и копирование ссылок не происходит.
3. Как вы вводите двумерный массив?
Скажем, программа принимает входной двумерный массив в виде n строк, каждый из которых содержит m чисел, разделенных пробелами. Как заставить программу читать ее? Пример того, как вы можете это сделать:
Или, не используя сложные вложенные вызовы:
Вы можете сделать то же самое с генераторами:
4. Обработка двумерного массива: пример
Предположим, вам задан квадратный массив (массив из n строк и n столбцов). Предположим, вы должны установить элементы главной диагонали, равные 1 (т. Е. Те элементы a[i][j] для которых i==j ), чтобы установить элементы выше, чем диагональ, равная 0, и установить элементы ниже этой диагонали, равной 2. То есть вам нужно создать такой массив (пример для n==4 ): (В этом случае вы можете сделать это вручную, установив a[0][0] = 1 , a[0][1] = 0 и т. Д., Но вы не будете делать это вручную для массивов из 100 строк и 100 столбцов , что часто бывает.)
Мы стремимся показать вам несколько способов решения этой проблемы. Во-первых, обратите внимание, что элементы, лежащие над главной диагональю, — это элементы a[i][j] для которых i<j , а для элементов ниже главной диагонали i>j . Таким образом, мы можем сравнить значения i и j , определяющие значение a[i][j] . Мы получаем следующий алгоритм:
Этот алгоритм медленный: он использует два цикла и для каждой пары (i,j) выполняет одну или две команды if . Если мы усложним алгоритм, мы сможем сделать это без условного оператора.
Сначала заполните основную диагональ, для которой нам понадобится один цикл:
Затем заполните нулями все элементы над главной диагональю. Чтобы сделать это, для каждой строки с номером i вам нужно присвоить значение a[i][j] для j = i+1 , . n-1 . Для этого вам нужны вложенные циклы:
По аналогии, для j = 0 , . i-1 задайте элементы a[i][j] равными 2 :
Вы можете комбинировать весь этот код и получить другое решение:
Вот еще одно решение, которое повторяет списки для создания следующих строк списка. i строка списка состоит из i чисел 2 , за которым следует одно целое число 1 , за которым следуют ni-1 нули:
Двумерный массив в Python
Array — это в основном структура данных, в которой данные хранятся линейно. В Python нет эксклюзивного объекта массива, потому что пользователь может выполнять все операции с массивом, используя список.
Итак, Python выполняет все операции, связанные с массивами, с помощью объекта списка. Массив в Python представляет собой упорядоченный набор элементов в последовательном порядке.
Синтаксис объявления массива:
Двумерные массивы — это в основном массивы внутри массивов. Здесь позиция элемента данных доступна с помощью двух индексов. Он представлен в виде таблицы rows and columns элементов данных.
Объявление двумерного массива
array-name = [ [d1, d2, . dn], [e1, e2, . en] ]
Вход в двумерный массив предоставляется в виде строк и столбцов.
Insert
Элементы в 2D-массив могут быть вставлены с помощью функции insert() указывающей индекс и позицию вставляемого элемента.
Как обновить элементы в двумерном массиве?
Элементы могут быть обновлены, а значения могут быть изменены путем переназначения значений с использованием индекса массива.
Как удалить значения?
Элементы из двумерного массива можно удалить с помощью метода del() .
Размер или длина
Длину массива можно определить с помощью метода len() .
Добавление
Элементы могут быть добавлены к массиву с помощью метода append() . Элемент добавляется в конец массива.
Нарезка
Нарезка массива используется для доступа к нескольким значениям в массиве.
How to initialize a two-dimensional array in Python?
I’m beginning python and I’m trying to use a two-dimensional list, that I initially fill up with the same variable in every place. I came up with this:
It gives the desired result, but feels like a workaround. Is there an easier/shorter/more elegant way to do this?
31 Answers 31
To initialize a two-dimensional list in Python, use
But don’t use [[v]*n]*n , it is a trap!
A pattern that often came up in Python was
which helped motivate the introduction of list comprehensions, which convert that snippet to
which is shorter and sometimes clearer. Usually, you get in the habit of recognizing these and often replacing loops with comprehensions.
Your code follows this pattern twice
This way is faster than the nested list comprehensions
Here are some python3 timings, for small and large lists
[[foo]*10]*10 creates a list of the same object repeated 10 times. You can’t just use this, because modifying one element will modify that same element in each row!
x[:] is equivalent to list(X) but is a bit more efficient since it avoids the name lookup. Either way, it creates a shallow copy of each row, so now all the elements are independent.
All the elements are the same foo object though, so if foo is mutable, you can’t use this scheme., you’d have to use