Заполнение двумерного массива python: Python создание и заполнение двумерного массива — Хабр Q&A

Двумерный массив в python и обработка элементов массива

На уроке рассматриваются алгоритмы работы с двумерными массивами в Python: создание матрицы, инициализация элементов, вывод, обработка элементов матрицы

Создание, вывод и ввод матрицы в Питоне

Для работы с матрицами в 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]]

• Вывод матрицы можно осуществить одним оператором, но такой простой способ не позволяет выполнять какой-то предварительной обработки элементов:

Результат: 

1. способ:

1 2 3 4 5

def printMatrix ( matrix ): for i in range ( len(matrix) ): for j in range ( len(matrix[i]) ): print ( "{:4d}".format(matrix[i][j]), end = "" ) print ()

def printMatrix ( matrix ): for i in range ( len(matrix) ): for j in range ( len(matrix[i]) ): print ( «{:4d}».format(matrix[i][j]), end = «» ) print ()

В примере i – это номер строки, а j – номер столбца;
len(matrix) – число строк в матрице.

2. способ:

1 2 3 4 5

def printMatrix ( matrix ): for row in matrix: for x in row: print ( "{:4d}".format(x), end = "" ) print ()

def printMatrix ( matrix ): for row in matrix: for x in row: print ( «{:4d}».format(x), end = «» ) print ()

Внешний цикл проходит по строкам матрицы (row), а внутренний цикл проходит по элементам каждой строки (x).

1
2
3
4
5
6

import random 
for i in range(N): 
    for j in range(M): 
       matrix[i][j] = random.randint ( 30, 60 )
       print ( "{:4d}".format(matrix[i][j]), end = "" ) 
    print()

import random for i in range(N): for j in range(M): matrix[i][j] = random.randint ( 30, 60 ) print ( «{:4d}».format(matrix[i][j]), end = «» ) print()

Обработка элементов двумерного массива

Нумерация элементов двумерного массива, как и элементов одномерного массива, начинается с нуля.
Т.е. 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)

Пример:
Найти сумму элементов двумерного массива.

✍ Решение: 

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.

Т.е. запись показаний в двумерном массиве выглядела бы так:

1. Распечатать температуру на 2-й метеостанции за 4-й день и на 3-й метеостанции за 1-й день.
2. Распечатать показания термометров всех метеостанций за 2-й день.
3. Определить среднюю температуру на 3-й метеостанции.
4. Распечатать, в какие дни и на каких метеостанциях температура была в диапазоне 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-й столбцы матрицы. Использовать два способа.

✍ Решение: 

1. 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

2. 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

1. Обработка и вывод вложенных списков Часто в задачах приходится хранить прямоугольные таблицы с данными. Такие таблицы называются матрицами или двумерными массивами. В языке программирования Питон таблицу можно представить в виде списка строк, каждый элемент которого является в свою очередь списком, например, чисел. Например, приведём программу, в которой создаётся числовая таблица из двух строк и трех столбцов, с которой производятся различные действия.

 
	
a = [[1, 2, 3], [4, 5, 6]]
print(a[0])
print(a[1])
b = a[0]
print(b)
print(a[0][2])
a[0][1] = 7
print(a)
print(b)
b[2] = 9
print(a[0])
print(b)

Здесь первая строка списка 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.

Для обработки и вывода списка, как правило, используют два вложенных цикла. Первый цикл перебирает номер строки, второй цикл бежит по элементам внутри строки. Например, вывести двумерный числовой список на экран построчно, разделяя числа пробелами внутри одной строки, можно так:

	
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
for i in range(len(a)):
    for j in range(len(a[i])):
        print(a[i][j], end=' ')
    print()
Однажды мы уже пытались объяснить, что переменная цикла for в Питоне может перебирать не только диапазон, создаваемый с помощью функции range(), но и вообще перебирать любые элементы любой последовательности. Последовательностями в Питоне являются списки, строки, а также некоторые другие объекты, с которыми мы пока не встречались. Продемонстрируем, как выводить двумерный массив, используя это удобное свойство цикла 
 for:
	
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
for row in a:
    for elem in row:
        print(elem, end=' ')
    print()
Естественно, для вывода одной строки можно воспользоваться
методом join():
for row in a:
    print(' '.join([str(elem) for elem in row]))
Используем два вложенных цикла для подсчета суммы всех
чисел в списке:
	
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
s = 0
for i in range(len(a)):
    for j in range(len(a[i])):
        s += a[i][j]
print(s)
Или то же самое с циклом не по индексу, а по значениям строк:
 
	
a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
s = 0
for row in a:
    for elem in row:
        s += elem
print(s)
2. Создание вложенных списков 
Пусть даны два числа: количество строк n и количество столбцов m. Необходимо создать список размером n×m, заполненный нулями.
Очевидное решение оказывается неверным:
В этом легко убедиться, если присвоить элементу a[0][0] значение 5, а потом вывести значение другого элемента a[1][0] — оно тоже будет равно 5. Дело в том, что [0] * m возвращает ccылку на список из m нулей.
Но последующее повторение этого элемента создает список из n элементов, которые являются ссылкой на один и тот же список (точно
так же, как выполнение операции b = a для списков не создает
новый список), поэтому все строки результирующего списка на самом деле
являются одной и той же строкой.
В визуализаторе обратите внимание на номер id у списков. Если у двух списков id совпадает, то это на самом деле один и тот же список в памяти.
	
n = 3
m = 4
a = [[0] * m] * n
a[0][0] = 5
print(a[1][0])
Таким образом, двумерный список нельзя создавать при помощи операции
повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов
(для начала просто из n нулей). Затем сделаем каждый
элемент списка ссылкой на другой одномерный список из m элементов:
	
n = 3
m = 4
a = [0] * n
for i in range(n):
    a[i] = [0] * m
Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:
	
n = 3
m = 4
a = []
for i in range(n):
    a.append([0] * m)
Но еще проще воспользоваться генератором: создать список из n элементов, каждый из которых будет списком,
состоящих из m нулей:
	
n = 3
m = 4
a = [[0] * m for i in range(n)]
В этом случае каждый элемент создается независимо от остальных
(заново конструируется список [0] * m для заполнения очередного
элемента списка), а не копируются ссылки на один и тот же список.
«Двумерные массивы». Язык программирования python
 
Описание презентации по отдельным слайдам:
 1 слайд  Описание слайда:
By снова я Двумерные массивы or список списков
 2 слайд  Описание слайда:
 Теория Ввод «вручную» Ввод с клавиатуры Заполнение определенным образом Теория
 3 слайд  Описание слайда:
Что это? Если просто, то двумерный список — это таблица. У каждой ячейки таблицы есть номер строки и номер столбца. Т.е. каждая ячейка имеет не один номер, как в обычном списке, а два: номер строки и номер столбца. Поэтому такие списки и называют «двумерными». В математике такие структуры называют «матрицы».
 4 слайд  Описание слайда:
Что это? Массив (в некоторых языках программирования также таблица, ряд, матрица) — тип или структура данных в виде набора компонентов (элементов массива), расположенных в памяти непосредственно друг за другом. При этом доступ к отдельным элементам массива осуществляется с помощью индексации, то есть через ссылку на массив с указанием номера (индекса) нужного элемента. За счёт этого, в отличие от списка, массив является структурой данных, пригодной для осуществления произвольного доступа к её ячейкам.
 5 слайд  Описание слайда:
Размерность Размерность массива — это количество индексов, необходимое для однозначной адресации элемента в рамках массива[2][3]. Форма или структура массива — сведения о количестве размерностей и размере (протяжённость) массива для каждой из размерностей[4]; может быть представлена одномерным массивом
 6 слайд  Описание слайда:
Создаем (python) ввод «вручную» a = [[1,2,3],[4,5,6]] print(a) Вывод:
 7 слайд  Описание слайда:
Разбираем: a = [[1,2,3],[4,5,6]] print(a[0]) print(a[1]) Что выведу?
 8 слайд  Описание слайда:
Разбираем: 0 строка — полностью 1 строка — полностью
 9 слайд  Описание слайда:
? Вопрос ? Как обратиться к конкретному элементу?
 10 слайд  Описание слайда:
! Ответ ! a = [[1,2,3],[4,5,6]] print(a[0]) print(a[1]) print(a[0][0],a[0][1],a[0][2])
 11 слайд  Описание слайда:
Еще теории: a[0] — это вся первая строка. Т.е. по сути, это элемент списка, который является списком. len(a) — количество строк len(a[0]) — количество элементов (столбцов) в первой строке.
 12 слайд  Описание слайда:
Пример: a = [[1,2,3],[4,5,6]] print(a[0]) print(a[1]) print(a[0][0],a[0][1],a[0][2]) print(len(a)) print(len(a[0]))
 13 слайд  Описание слайда:
теория Разумеется, что мы не будем заполнять и выводить это вручную. Сначала посмотрим на вывод. Взять все строки по очереди и вывести на экран.
 14 слайд  Описание слайда:
Просто для вывода!!!
 15 слайд  Описание слайда:
Заполнение определенным образом Заполнить и вывести на экран числа от 10 до 99 включительно.
 16 слайд  Описание слайда:
Заполнение определенным образом a = [] #создаем пустой список k = 10 # просто начальное значение, может быть 	 любым for r in range(9): # 9 строк a.append([]) # создаем пустую строку for c in range(10): # в каждой строке — 10 				 элементов a[r].append(k) # добавляем очередной 				 элемент в строку k += 1 		 # увеличиваем значение 				 счетчика for r in a: print(r)
 17 слайд  Описание слайда:
Заполнение 0, 1, 2 Заполнить массив по определенным правилам: на главной диагонали все элементы = 1, что выше = 0, а что ниже = 2. на вход дается n – размер квадратного массива.
 18 слайд  Описание слайда:
Заполнение 0, 1, 2 a = [] n=int(input()) for r in range(n): a.append([]) for c in range(n): if r==c: a[r].append(‘1’) elif r<c: a[r].append(‘0’) else: a[r].append(‘2’) for r in a: print(r)
 19 слайд  Описание слайда:
Ввод с клавиатуры n = int(input()) # создаем количество строк!!! a = [] # создаем пустой список for i in range(n): # пошли по строкам с 0 row = input().split() # вводим список до Enter for i in range(len(row)): # цикл, от 0 до количества 					row row[i] = int(row[i]) # перевод в число элемента 				списка row a.append(row) # добавлем в наш список 					(массив) for i in a: print(i) # вывод на экран
 20 слайд  Описание слайда:
Ввод с клавиатуры n,m=map(int,input().split()) #читаем справа налево! a = [] # создаем пустой список for i in range(n): # цикл до n b = [] # создаем список b for j in range(m): # цикл до m b.append(int(input())) # вводим переменную a.append(b) # записываем в список for i in range(n): # цикл до n for j in range(m): # цикл до m print(int(a[i][j]),end=’ ‘) # выводим элемент print() # переход на следующую строку
 21 слайд  Описание слайда:
Минус такого способа:
 22 слайд  Описание слайда:
Правильное решение проблемы n,m = map(int,input().split()) a = [] for i in range(n): row = input().split() for j in range(m): row[j] = int(row[j]) a.append(row) for i in range(n): for j in range(m): print(a[i][j], end=’ ‘) print()
 23 слайд  Описание слайда: 24 слайд  Описание слайда:
задача
 25 слайд  Описание слайда:
n,m = map(int,input().split()) a = [] for i in range(n): row = input().split() for j in range(m): row[j] = int(row[j]) a.append(row) maxm=a[0][0] maxi=0 maxj=0 for i in range(n): for j in range(m): if a[i][j]>maxm: maxm=a[i][j] maxi=i maxj=j if a[i][j]==maxm: if i<maxi: maxi=i elif maxi==i: if j<maxj: maxj=j print(maxi,maxj)
 26 слайд  Описание слайда:
задача Прочитать массив и вывести его в файл, в привычном виде: 3 4 1 2 3 1 1 2 3 0 4 5 6 3
 27 слайд  Описание слайда:
Текстовые файлы s1 = open(‘input.txt’,’r’) t=open(‘output.txt’,’w’) f=s1.readline().split() n=int(».join(f[0])) m=int(».join(f[1])) print(n,m) a = [] for i in range(n): row=s1.readline().split() for j in range(len(row)): row[j]=int(row[j]) a.append(row) print(a) for i in range(n): for j in range(m): t.writelines(str(a[i][j])+’ ‘) t.write(‘\n’) s1.close() t.close()
 28 слайд  Описание слайда:
Разбор программы s1 = open(‘input.txt’,’r’) # открытие файла чтения t=open(‘output.txt’,’w’) # открытия файла записи f=s1.readline().split() #считаывем первую строку n=int(».join(f[0])) m=int(».join(f[1])) print(n,m) a = [] for i in range(n): row=s1.readline().split() for j in range(len(row)): row[j]=int(row[j]) a.append(row) print(a) for i in range(n): for j in range(m): t.writelines(str(a[i][j])+’ ‘) t.write(‘\n’) s1.close() t.close()
 
 Курс профессиональной переподготовки
 Учитель информатики
 
 Курс профессиональной переподготовки
 Учитель математики и информатики
 
 Курс повышения квалификации
Найдите материал к любому уроку,
указав свой предмет (категорию), класс, учебник и тему:
 Выберите категорию: 
 Все категорииАлгебраАнглийский языкАстрономияБиологияВнеурочная деятельностьВсеобщая историяГеографияГеометрияДиректору, завучуДоп. образованиеДошкольное образованиеЕстествознаниеИЗО, МХКИностранные языкиИнформатикаИстория РоссииКлассному руководителюКоррекционное обучениеЛитератураЛитературное чтениеЛогопедия, ДефектологияМатематикаМузыкаНачальные классыНемецкий языкОБЖОбществознаниеОкружающий мирПриродоведениеРелигиоведениеРодная литератураРодной языкРусский языкСоциальному педагогуТехнологияУкраинский языкФизикаФизическая культураФилософияФранцузский языкХимияЧерчениеШкольному психологуЭкологияДругое
 Выберите класс: 
 Все классыДошкольники1 класс2 класс3 класс4 класс5 класс6 класс7 класс8 класс9 класс10 класс11 класс
 Выберите учебник: 
 Все учебники
 Выберите тему: 
 Все темы
 также Вы можете выбрать тип материала:
 
Краткое описание документа:
Массив (в
некоторых языках
программирования также
таблица, ряд, матрица) — тип или структура
данных в
виде набора компонентов (элементов массива), расположенных в памяти
непосредственно друг за другом. При этом доступ к отдельным элементам массива
осуществляется с помощью индексации,
то есть через ссылку на массив с указанием номера (индекса)
нужного элемента. За счёт этого, в отличие от списка,
массив является структурой данных, пригодной для осуществления произвольного
доступа к её ячейкам.
Общая информация
 Номер материала: 
 ДБ-1016184
Похожие материалы
Вам будут интересны эти курсы:
 Оставьте свой комментарий 
Двумерный массив в python — CodeRoad
Я хочу знать, как объявить двумерный массив в Python.
arr = [[]]

arr[0].append("aa1")
arr[0].append("aa2")
arr[1].append("bb1")
arr[1].append("bb2")
arr[1].append("bb3")
Первые два задания работают нормально. Но когда я пытаюсь сделать, arr[1].append("bb1"), я получаю следующую ошибку:
IndexError: list index out of range.
Я делаю что-нибудь глупое, пытаясь объявить массив 2-D?
Редактировать : 
но я не знаю количество элементов в массиве (как строк, так и столбцов).
 python  multidimensional-array  Поделиться  Источник  SyncMaster     18 ноября 2011 в 13:28 
 10 Ответов 
 
60

У вас нет «declare» массивов или чего-то еще в python. Вы просто назначаете (новой) переменной. Если вам нужен многомерный массив, просто добавьте новый массив в качестве элемента массива.
arr = []
arr.append([])
arr[0].append('aa1')
arr[0].append('aa2')
или
arr = []
arr.append(['aa1', 'aa2'])
  Поделиться  ThiefMaster     18 ноября 2011 в 13:30 
 
53

В Python нет многомерных массивов как таковых, у вас есть список, содержащий другие списки.
>>> arr = [[]]
>>> len(arr)
1
То, что вы сделали, — это объявили список, содержащий один список.  Таким образом, arr[0] содержит список, но arr[1] не определен.
Список, содержащий два списка, можно определить следующим образом:
arr = [[],[]]
Или для определения более длинного списка вы можете использовать:
>>> arr = [[] for _ in range(5)]
>>> arr
[[], [], [], [], []]
Но вот чего тебе не следует делать:
arr = [[]] * 3
Поскольку это помещает один и тот же список во все три места в списке контейнеров:
>>> arr[0].append('test')
>>> arr
[['test'], ['test'], ['test']]
  Поделиться  Dave Webb     18 ноября 2011 в 13:33 
 
18

То, что вы используете здесь, — это не массивы, а списки (списков).
Если вы хотите многомерные массивы в Python, вы можете использовать Numpy массивов. Вам нужно было бы знать форму заранее.
Например:
 import numpy as np
 arr = np.empty((3, 2), dtype=object)
 arr[0, 1] = 'abc'
  Поделиться  Bruno     18 ноября 2011 в 13:40 
 
3

Вы пытаетесь добавить ко второму элементу массива, но он не существует.
Создать ее.
arr = [[]]

arr[0].append("aa1")
arr[0].append("aa2")
arr.append([])
arr[1].append("bb1")
arr[1].append("bb2")
arr[1].append("bb3")
  Поделиться  tony     18 ноября 2011 в 13:34 
 
2

При построении многомерных списков в Python я обычно использую что-то похожее на решение ThiefMaster, но вместо добавления элементов в индекс 0, а затем добавления элементов в индекс 1 и т. д., Я всегда использую индекс -1 , который автоматически является индексом последнего элемента в массиве.
т.е.
arr = []

arr.append([])
arr[-1].append("aa1")
arr[-1].append("aa2")

arr.append([])
arr[-1].append("bb1")
arr[-1].append("bb2")
arr[-1].append("bb3")
будет создан 2D-массив (фактически список списков), который вы ищете.
  Поделиться  Lurchman     30 декабря 2012 в 17:52 
 
2

Мы можем создать многомерный массив динамически следующим образом,
Создайте 2 переменные для чтения x и y из стандартного ввода:
 print("Enter the value of x: ")
 x=int(input())

 print("Enter the value of y: ")
 y=int(input())
Создайте массив списка с начальными значениями, заполненными 0 или чем-либо еще, используя следующий код
z=[[0 for row in range(0,x)] for col in range(0,y)]
создает количество строк и столбцов для данных массива.
Считывание данных из стандартного ввода:
for i in range(x):
         for j in range(y):
             z[i][j]=input()
отображение результата:
for i in range(x):
         for j in range(y):
             print(z[i][j],end=' ')
         print("\n")
или используйте другой способ отображения выше динамически созданного массива is,
for row in z:
     print(row)
  Поделиться  PK4Android     25 августа 2014 в 10:24 
 
2

Вы можете сначала добавить элементы в инициализированный массив, а затем для удобства преобразовать его в массив numpy.
import numpy as np
a = [] # declare null array
a.append(['aa1']) # append elements
a.append(['aa2'])
a.append(['aa3'])
print(a)
a_np = np.asarray(a) # convert to numpy array
print(a_np)
  Поделиться  Sammy     23 августа 2018 в 21:25 
 
1

a = [[] for index in range(1, n)]
  Поделиться  user306080     23 ноября 2012 в 07:10 
 
0

x=3#rows
y=3#columns
a=[]#create an empty list first
for i in range(x):
    a.append([0]*y)#And again append empty lists to original list
    for j in range(y):
         a[i][j]=input("Enter the value")
  Поделиться  Rohith  Rangaraju     15 мая 2016 в 07:04 
 
0

Для compititve программирования
1) для ввода значения в 2D-массив
row=input()
main_list=[]
for i in range(0,row):
    temp_list=map(int,raw_input().split(" "))
    main_list.append(temp_list)
2) для отображения массива 2D
for i in range(0,row):
    for j in range(0,len(main_list[0]):
        print main_list[i][j],
        print
  Поделиться  Raj     06 июля 2017 в 02:18 
Похожие вопросы:
 
 Как определить двумерный массив в Python
 Я хочу определить двумерный массив без инициализированной длины, как это: Matrix = [][] но это не работает… Я попробовал код ниже, но он тоже неправильный: Matrix = [5][5] Ошибка : Traceback ……

 Как передать двумерный массив от C до Python
 Я хочу передать двумерный массив в python из C. Как я могу использовать Py_BuildValue() и PyEval_CallObject() ? Например, я могу использовать следующий код для передачи строки из C в python: pModule…

 Input двумерный массив n*n в python 2.7
 Я пытаюсь взять двумерный массив input в python, который может иметь n строк и столбцов. То, что я пробовал, это x = raw_input()[2:-2].split(‘,’) Мой input является следующим…

 Объединить двумерный массив в массив объектов
 Я хотел бы знать, как бы я объединил этот двумерный массив let arr[ [‘Reference’, ‘Price’], [‘232323DD, 15.00] ]; Я хочу превратить это в [ {name: ‘Reference’, value: ‘232323DD’}, {name: ‘Price’,…

 Как создать двумерный массив в python
 Как создать двумерный массив в python. В частности, инициализируя его с помощью существующего массива для первого индекса. У меня есть массив: x = [1.0, 2.0, 3.0] и я хочу создать из него новый: y =…

 Двумерный массив в ios
 Я хочу использовать двумерный массив в ios, например, я хочу подготовить массив для источника данных tableview , UITableViewCell array[sections][rows]; Что-то вроде этого, и здесь я тоже не могу…

 как передать двумерный массив в качестве параметра в функцию и вернуть двумерный массив в c++?
 В C++, как передать двумерный массив в качестве параметра в функции и эта функция возвращает двумерный массив? если у меня есть массив, определенный следующим образом: struct Hello { int a; int b;…

 двумерный массив с shared_ptr
 Мне нужен двумерный массив заполненный экземплярами различных производных типов мой код выглядит так: std::array<std::array<std::shared_ptr<Base>, 1>, 1> b; b[1][1] =…

 Как определить динамический двумерный массив в python?
 Я хочу определить динамический двумерный массив в python. Я не знаю, сколько строк будет иметь мой двумерный массив в начале моей программы. Я хотел бы определить новые строки в этом массиве 2D по…

 python двумерный массив со строками и столбцами
 Создайте двумерный массив с именем A с ROWS строками и COLS столбцами. ROWS и COLSS задаются пользователем во время выполнения. Заполните A произвольно выбранными целыми числами из диапазона […

Прежде, чем мы сделаем игру «Сапер» и «Блоки» нужно научится работать с двумерными списками.
Если просто, то двумерный список — это таблица. У каждой ячейки таблицы есть номер строки и номер столбца.
Т.е. каждая ячейка имеет не один номер, как в обычном списке, а два: номер строки и номер столбца.
Поэтому такие списки и называют «двумерными». В математике такие структуры называют «матрицы».
Создадим простой двумерный список:
a = [[1,2,3],[4,5,6]]
print(a)
Не очень похоже на таблицу, правда?
А если так:
a = [[1,2,3],[4,5,6]]
print(a[0])
print(a[1])
a[0] — это вся первая строка. Т.е. по сути, это элемент списка, который является списком.
len(a) — количество строк
len(a[0]) — количество элементов (столбцов) в первой строке.
Разумеется, что мы не будем заполнять и выводить это вручную.
Сначала посмотрим на вывод.
Взять все строки по очереди и вывести на экран.
for r in a:
    print(r)
Знакомый прием, правда? Спасибо Питону, он позволяет работать со списками просто и элегантно.
А теперь посмотрим на заполнение:
a = []
k = 10 # просто начальное значение, может быть любым
for r in range(6): # 6 строк
    a.append([]) # создаем пустую строку
    for c in range(10): # в каждой строке - 10 элементов
        a[r].append(k) # добавляем очередной элемент в строку
        k += 1 # увеличиваем значение счетчика

for r in a:
    print(r)

Начал с k = 10 для того, чтобы все числа были двузначные (попробуйте начать с k = 1 и поймете, о чем я говорю)
Теперь — заполнение случайными значениями:
a = []
for r in range(6): # 6 строк
    a.append([]) # создаем пустую строку
    for c in range(10): # в каждой строке - 10 элементов
        a[r].append(rnd(10,100)) # добавляем очередной элемент в строку
А теперь создадим очень простой класс и двумерный список, который заполним экземплярами этого класса:
class cell():
    def __init__(self):
        self.n = rnd(10) 

a = []
nr = 6 # количество строк
nc = 11 # количество столбцов
for r in range(nr):
    a.append([])
    for c in range(nc):
        a[r].append(cell()) # добавляем очередной элемент в строку

for r in range(nr): # перебираем все строки по номерам
    for c in range(nc): # в каждой строке перебираем все столбцы по номерам
        print(a[r].n, end = ' ')
		# выводим на экран значения свойства "а" элемента, стоящего в данной строке и данном столбце
		# после вывода не нужно переходить на другую строку (на экране) - ставим пробел
    print() # когда выведем очередную строку, то переводим курсор (на экране) на новую строку
Усложним задачу. Сделаем класс «Ячейка» и нарисуем таблицу ячеек. Вначале класс и тестовая ячейка:
from random import randrange as rnd, choice
from tkinter import *
 
root = Tk()
root.geometry('800x600')
 
canv = Canvas(root, bg = 'white')
canv.pack(fill = BOTH, expand = 1)


m = 34 # размер ячеек
d = 2 # размер поля вокруг ячейки
nr = 6 # количество строк
nc = 8 # количество столбцов
x0 = m // 2 # отступ от левого края
y0 = m // 2 # отступ от вернего края
colors = ['red','yellow','cyan','green']
 
class cell():
    def __init__(self, r, c): # при создании указываем номер строки и столбца, в который помещаем
        self.n = rnd(10) # значение, с которым будем работать
        self.r = r # Номер сторки в двумерном списке.
        self.c = c # Номер столбца ...
        self.color = choice(colors) # случайный цвет из списка
        self.id = canv.create_rectangle(-100,0,-100,0,fill = self.color) # квадратик ячейки
        self.id_text = canv.create_text(-100,0, text = self.n, font = "Arial " + str(m//2)) # текст в квадратике, размер зависит от масштаба
        self.paint()
 
    def paint(self):
        x1 = x0 + self.c * m + d
        # рассчитать координаты левого верхнего угла.
        y1 = y0 + self.r * m + d
        # координаты правого нижнего угла.
        x2 = x1 + m - 2*d # - r
        y2 = y1 + m - 2*d
        canv.coords(self.id,x1,y1,x2,y2)
        canv.itemconfig(self.id,fill = self.color)
        # текст в центр ячейки
        x = (x1 + x2) / 2
        y = (y1 + y2) / 2
        canv.coords(self.id_text,x,y)
        canv.itemconfig(self.id_text, text = self.n)
 
c_test = cell(2,2)

mainloop()
В результате — грустная и одинокая «клетка» на экране. Случайного цвета и со случайным значением.
a = []
for r in range(nr): # 6 строк
    a.append([]) # создаем пустую строку
    for c in range(nc): # в каждой строке - 10 элементов
        a[r].append(cell(r,c)) # добавляем очередной элемент в строку

mainloop()
Мы использовали класс cell, потому что это удобно — «завернуть» несколько параметров в «одну переменную». Без использования класса мы смогли бы хранить только числовое значение в ячейке. А так у нас есть уже, как минимум, два значения — это цвет и числовое значение.
Рассмотрим перебор всех ячеек. Например, приведем в соответствие цвет и значение в ячейке: выделим значения от 0 до 2 голубым, от 3 до 5 зеленым, 6 — 8 — желтым и 9 — красным:
def task(event):
    for r in range(nr): # перебираем все строки
        for c in range(nc): # перебираем все столбцы
            if 0 <= a[r].n <= 2:
                a[r].color = 'cyan'
            elif a[r].n <= 5:
                a[r].color = 'green'
            elif a[r].n <= 8:
                a[r].color = 'yellow'
            else:
                a[r].color = 'red'

canv.bind('<Button-1>',task)

mainloop()
Не работает?
У меня тоже не работает.
Как выяснить, в чем может быть дело?
Вначале стоит проверить, выполняется ли функция task вообще. В этом поможет обычный print(‘!’)
Если выполняется, то так же нужно проверить выполнение какого-либо условия.
Все работает… но изменений-то не видно!
Ключевое слово видно.
Если еще не догадались, то подсказываю: нужно отобразить изменения.
a[r].paint()
Рассмотрим решение некоторых задач.
Найдем сумму всех:
def task(event):
    s = 0
    for r in range(nr):
        for c in range(nc):
            s += a[r].n
    print(s)
А теперь выведем результат не в консоль, а прямо на холст:
def task(event):
    s = 0
    for r in range(nr):
        for c in range(nc):
            s += a[r].n
    x1 = x0 + nc * m + d # координаты левого верхнего угла правой ячейки
    x1 = x1 + 2*m # отступим от нее на размер двух ячеек
    y1 = y0
    x2 = x1 + m
    y2 = y1 + m
    canv.create_rectangle(x1,y1,x2,y2)
    x = (x2 + x1) / 2
    y = (y2 + y1) / 2
    canv.create_text(x,y, text = s, font = 'Arial' + str(m//2))
Заполнение значениями по порядку, по строкам:
def task(event):
    k = 0
    for r in range(nr):
        for c in range(nc):
            a[r].n = k
            k += 1
            a[r].color = '#99ccdd'
            a[r].paint()
1. Заполнить одним цветом, значениями по порядку, по строкам
2. Заполнить одним цветом, значениями по порядку, по столбцам
3. Заполнить номерами строк
4. Заполнить номерами столбцов
5. Создать таблицу сложения
6. Создать таблицу умножения
7. Заполнить повторяющимся набором (1,2,3,4,5) по строкам
8*. Заполнить повторяющимся набором (1,1,2,2,3,3,4,4,5,5). Возможно, потребуется модуль itertools
9. Заполнить двумя цветами в шахматном порядке, без чисел
 Заполнить случайными цветами и числами, затем:
 10. Найти сумму всех элементов
 11. Найти сумму красных всего массива
 12*. Найти среднее для каждого цвета, вывести рядом
 13**. Нарисовать столбчатую диаграмму по суммам каждого цвета. Возможно, потребуется matplotlib
 14**. Нарисовать круговую диаграмму по суммам каждого цвета
 15. Выделить нули оранжевым, остальные — серым
 16. Строки, в которых нет нулей сделать оранжевыми
17. Столбцы, в которых нет нулей сделать оранжевыми
Рассмотрим, как определить ячейку, по которой щелкнули мышкой.
Мы уже рассчитывали координаты по номеру строки и столбца. Надо просто сделать обратный расчет:
def task(event):
    c = (event.x - x0) // m
    r = (event.y - y0) // m
    a[r].color = 'orange'
    a[r].paint()
 По щелчку:
18. Выделить оранжевым цветом элемент, по которому щелкнули, все остальные перекрасить в серый
19. Выделить оранжевым цветом все ячейки в текущем столбце
20. Выделить оранжевым цветом все ячейки в текущей строке
22. Выделить оранжевым цветом диагонали, на которых находится ячейка, все остальные отметить серым
23. Выделить оранжевым цветом соседей (слева, справа, сверху, снизу), остальные ячейки закрасить серым
24. Выделить ячейку и ее соседей по сторонам и диагоналям (все 8 ячеек)
25. Выделить ячейку, ее соседей и соседей соседей (4 + 8) Считать соседями только клетки, с которыми есть общая сторона
26. Записать 0 в ячейки, которые имеют такой же цвет, как и та, в которую щелкнули
27*. Значение ячейки, по которой щелкнули, увеличить на 50%, ее соседей на 25%, их соседей — на 10%
28. Если значение ячейки, по которой щелкнули, меньше всех своих соседей (по сторонам), то перекрасить ее в синий, если больше — то в красный. Иначе оставить, как есть.
Python | Свести двумерный массив NumPy в 1D массив
 Для заданного двумерного массива массивов задача состоит в том, чтобы сгладить двумерный массивный массив в одномерный массив. Ниже приведены несколько способов решения задачи.
 Способ № 1: Использование np.flatten ()
  
import numpy as np 
  
ini_array1 = np.array([[1, 2, 3], [2, 4, 5], [1, 2, 3]]) 
  
print("initial array", str(ini_array1)) 
  
result = ini_array1.flatten() 
  
print("New resulting array: ", result) 
 Выход:
initial array [[1 2 3]
 [2 4 5]
 [1 2 3]]
New resulting array:  [1 2 3 2 4 5 1 2 3]
 Способ № 2: Использование np.ravel ()
  
import numpy as np 
  
ini_array1 = np.array([[1, 2, 3], [2, 4, 5], [1, 2, 3]]) 
  
print("initial array", str(ini_array1)) 
  
result = ini_array1.ravel() 
  
print("New resulting array: ", result) 
 Выход:
initial array [[1 2 3]
 [2 4 5]
 [1 2 3]]
New resulting array:  [1 2 3 2 4 5 1 2 3]
 Способ № 3: Использование np.reshape ()
  
import numpy as np 
  
ini_array1 = np.array([[1, 2, 3], [2, 4, 5], [1, 2, 3]]) 
  
print("initial array", str(ini_array1)) 
  
result = ini_array1.reshape([1, 9]) 
  
print("New resulting array: ", result) 
 Выход:
initial array [[1 2 3]
 [2 4 5]
 [1 2 3]]
New resulting array:  [[1 2 3 2 4 5 1 2 3]]
Рекомендуемые посты:
Python | Свести двумерный массив NumPy в 1D массив
0.00 (0%) 0 votes
NumPy в Python. Часть 1 / Хабр
Предисловие переводчика
 
 Доброго времени суток, Хабр. Запускаю цикл статей, которые являются переводом небольшого мана по numpy, ссылочка. Приятного чтения.
Введение
 
 NumPy это open-source модуль для python, который предоставляет общие математические и числовые операции в виде пре-скомпилированных, быстрых функций. Они объединяются в высокоуровневые пакеты. Они обеспечивают функционал, который можно сравнить с функционалом MatLab. NumPy (Numeric Python) предоставляет базовые методы для манипуляции с большими массивами и матрицами. SciPy (Scientific Python) расширяет функционал numpy огромной коллекцией полезных алгоритмов, таких как минимизация, преобразование Фурье, регрессия, и другие прикладные математические техники.
 
Установка
 
 Если у вас есть Python(x, y) (Примечание переводчика: Python(x, y), это дистрибутив свободного научного и инженерного программного обеспечения для численных расчётов, анализа и визуализации данных на основе языка программирования Python и большого числа модулей (библиотек)) на платформе Windows, то вы готовы начинать. Если же нет, то после установки python, вам нужно установить пакеты самостоятельно, сначала NumPy потом SciPy. Установка доступна здесь. Следуйте установке на странице, там всё предельно понятно.
Немного дополнительной информации
 
 Сообщество NumPy и SciPy поддерживает онлайн руководство, включающие гайды и туториалы, тут: docs.scipy.org/doc.
Импорт модуля numpy
Есть несколько путей импорта. Стандартный метод это — использовать простое выражение:
>>> import numpy

 Тем не менее, для большого количества вызовов функций numpy, становиться утомительно писать numpy.X снова и снова. Вместо этого намного легче сделать это так:
>>> import numpy as np

 Это выражение позволяет нам получать доступ к numpy объектам используя np.X вместо numpy.X. Также можно импортировать numpy прямо в используемое пространство имен, чтобы вообще не использовать функции через точку, а вызывать их напрямую:
>>> from numpy import *

 Однако, этот вариант не приветствуется в программировании на python, так как убирает некоторые полезные структуры, которые модуль предоставляет. До конца этого туториала мы будем использовать второй вариант импорта (import numpy as np).
Массивы
 
 Главной особенностью numpy является объект array. Массивы схожи со списками в python, исключая тот факт, что элементы массива должны иметь одинаковый тип данных, как float и int. С массивами можно проводить числовые операции с большим объемом информации в разы быстрее и, главное, намного эффективнее чем со списками.
Создание массива из списка:
a = np.array([1, 4, 5, 8], float)
>>> a
array([ 1.,  4.,  5.,  8.])
>>> type(a)
<class 'numpy.ndarray'>

 Здесь функция array принимает два аргумента: список для конвертации в массив и тип для каждого элемента. Ко всем элементам можно получить доступ и манипулировать ими также, как вы бы это делали с обычными списками:
>>> a[:2]
array([ 1.,  4.])
>>> a[3]
8.0
>>> a[0] = 5.
>>> a
array([ 5.,  4.,  5.,  8.])

 Массивы могут быть и многомерными. В отличии от списков можно задавать команды в скобках. Вот пример двумерного массива (матрица):
>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> a
array([[ 1.,  2.,  3.],
[ 4.,  5.,  6.]])
>>> a[0,0]
1.0
>>> a[0,1]
2.0

 Array slicing работает с многомерными массивами аналогично, как и с одномерными, применяя каждый срез, как фильтр для установленного измерения. Используйте «:» в измерении для указывания использования всех элементов этого измерения:
>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> a[1,:]
array([ 4.,  5.,  6.])
>>> a[:,2]
array([ 3.,  6.])
>>> a[-1:, -2:]
array([[ 5.,  6.]])

 Метод shape возвращает количество строк и столбцов в матрице:
>>> a.shape
(2, 3)

 Метод dtype возвращает тип переменных, хранящихся в массиве:
>>> a.dtype
dtype('float64')

 Тут float64, это числовой тип данных в numpy, который используется для хранения вещественных чисел двойной точности. Так как же float в Python.
Метод len возвращает длину первого измерения (оси):
a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> len(a)
2

 Метод in используется для проверки на наличие элемента в массиве:
>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> 2 in a
True
>>> 0 in a
False

 Массивы можно переформировать при помощи метода, который задает новый многомерный массив. Следуя следующему примеру, мы переформатируем одномерный массив из десяти элементов во двумерный массив, состоящий из пяти строк и двух столбцов:
>>> a = np.array(range(10), float)
>>> a
array([ 0.,  1.,  2., 3.,  4.,  5.,  6.,  7.,  8.,  9.])
>>> a = a.reshape((5, 2))
>>> a
array([[ 0.,  1.],
[ 2.,  3.],
[ 4.,  5.],
[ 6.,  7.],
[ 8.,  9.]])
>>> a.shape
(5, 2)

 Обратите внимание, метод reshape создает новый массив, а не модифицирует оригинальный.
Имейте ввиду, связывание имен в python работает и с массивами. Метод copy используется для создания копии существующего массива в памяти:
>>> a = np.array([1, 2, 3], float)
>>> b = a
>>> c =  a.copy()
>>> a[0] = 0
>>> a
array([0., 2., 3.])
>>> b
array([0., 2., 3.])
>>> c
array([1., 2., 3.])

 Списки можно тоже создавать с массивов:
>>> a = np.array([1, 2, 3], float)
>>> a.tolist()
[1.0, 2.0, 3.0]
>>> list(a)
[1.0, 2.0, 3.0]

 Можно также переконвертировать массив в бинарную строку (то есть, не human-readable форму). Используйте метод tostring для этого. Метод fromstring работает в для обратного преобразования. Эти операции иногда полезны для сохранения большого количества данных в файлах, которые могут быть считаны в будущем.
>>> a = array([1, 2, 3], float)
>>> s = a.tostring()
>>> s
'\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@'
>>> np.fromstring(s)
array([ 1.,  2.,  3.])

 Заполнение массива одинаковым значением.
>>> a = array([1, 2, 3], float)
>>> a
array([ 1.,  2.,  3.])
>>> a.fill(0)
>>> a
array([ 0.,  0.,  0.])

 Транспонирование массивов также возможно, при этом создается новый массив:
>>> a = np.array(range(6), float).reshape((2, 3))
>>> a
array([[ 0.,  1.,  2.],
[ 3.,  4.,  5.]])
>>> a.transpose()
array([[ 0.,  3.],
[ 1.,  4.],
[ 2.,  5.]])

 Многомерный массив можно переконвертировать в одномерный при помощи метода flatten:
>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> a
array([[ 1.,  2.,  3.],
[ 4.,  5.,  6.]])
>>> a.flatten()
array([ 1.,  2.,  3.,  4.,  5.,  6.])

 Два или больше массивов можно сконкатенировать при помощи метода concatenate:
>>> a = np.array([1,2], float)
>>> b = np.array([3,4,5,6], float)
>>> c = np.array([7,8,9], float)
>>> np.concatenate((a, b, c))
array([1., 2., 3., 4., 5., 6., 7., 8., 9.])

 Если массив не одномерный, можно задать ось, по которой будет происходить соединение. По умолчанию (не задавая значения оси), соединение будет происходить по первому измерению:
>>> a = np.array([[1, 2], [3, 4]], float)
>>> b = np.array([[5, 6], [7,8]], float)
>>> np.concatenate((a,b))
array([[ 1.,  2.],
[ 3.,  4.],
[ 5.,  6.],
[ 7.,  8.]])
>>> np.concatenate((a,b), axis=0)
array([[ 1.,  2.],
[ 3.,  4.],
[ 5.,  6.],
[ 7.,  8.]])
>>>
np.concatenate((a,b), axis=1)
array([[ 1.,  2.,  5.,  6.],
[ 3.,  4.,  7.,  8.]])

 В заключении, размерность массива может быть увеличена при использовании константы newaxis в квадратных скобках:
>>> a = np.array([1, 2, 3], float)
>>> a
array([1., 2., 3.])
>>> a[:,np.newaxis]
array([[ 1.],
[ 2.],
[ 3.]])
>>> a[:,np.newaxis].shape
(3,1)
>>> b[np.newaxis,:]
array([[ 1.,  2.,  3.]])
>>> b[np.newaxis,:].shape
(1,3)

 Заметьте, тут каждый массив двумерный; созданный при помощи newaxis имеет размерность один. Метод newaxis подходит для удобного создания надлежаще-мерных массивов в векторной и матричной математике.
На этом у нас конец первой части перевода. Спасибо за внимание.
 Двумерные списки (массивы) — Learn Python 3 
 В реальном мире Часто задачи должны хранить прямоугольную таблицу данных. [расскажите об этом подробнее!]
Такие таблицы называются  матрицами  или двумерными массивами. В Python любую таблицу можно представить как список списков (список, где каждый элемент, в свою очередь, является списком).
Например, вот программа, которая создает числовую таблицу с двумя строками и тремя столбцами, а затем выполняет с ней некоторые манипуляции:
 Нет 
 a = [[1, 2, 3], [4, 5, 6]]
print (a [0])
печать (a [1])
б = а [0]
печать (б)
print (a [0] [2])
а [0] [1] = 7
печать (а)
печать (б)
b [2] = 9
print (a [0])
печать (б)
 
 Первый элемент  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 ,  а [1] [2] == 6 .
 Для обработки двумерного массива обычно используется вложенный
петли. Первый цикл проходит по номеру строки, второй цикл проходит по элементам внутри строки.
Например, вот как вы выводите на экран двумерный числовой список построчно,
разделяя числа пробелами:
 Нет 
 a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
для i в диапазоне (len (a)):
    для j в диапазоне (len (a [i])):
        print (a [i] [j], end = '')
    Распечатать()
 
 Мы уже пытались объяснить, что переменная цикла for в Python может выполнять итерацию не только по диапазону  () , но в целом по всем элементам любой последовательности.Последовательности в Python — это списки и строки (и некоторые другие объекты, которые мы еще не встречали). Посмотрите, как вы можете распечатать двумерный массив, используя эту удобную функцию цикла  для :
 Нет 
 a = [[1, 2, 3, 4], [5, 6], [7, 8, 9]]
для строки в:
    для элемента в ряду:
        печать (элемент, конец = '')
    Распечатать()
 
 Естественно, для вывода одной строки можно использовать
метод  join () :
 для ряда в:
    print ('' .join ([str (elem) для элемента в строке]))
 
 Вот как вы можете использовать 2 вложенных цикла для вычисления суммы всех
числа в двумерном списке:
.
 Инициализация двумерного массива в Python? 
 Переполнение стека
 Около
 Товары
 Для команд
 Переполнение стека
 Общественные вопросы и ответы
 Переполнение стека для команд
 Где разработчики и технологи делятся частными знаниями с коллегами
 работы
 Программирование и связанные с ним технические возможности карьерного роста
 Талант
 Нанимайте технических специалистов и создавайте свой бренд работодателя
 реклама
 Обратитесь к разработчикам и технологам со всего мира
 О компании
 .
 циклов — итерация по двумерному списку Python 
 Переполнение стека
 Около
 Товары
 Для команд
 Переполнение стека
 Общественные вопросы и ответы
 Переполнение стека для команд
 Где разработчики и технологи делятся частными знаниями с коллегами
 работы
 Программирование и связанные с ним технические возможности карьерного роста
 Талант
 Нанимайте технических специалистов и создавайте свой бренд работодателя
 реклама
 Обратитесь к разработчикам и технологам со всего мира
.
 Создание двумерного массива Python из двух одномерных массивов в Python 
 Переполнение стека
 Около
 Товары
 Для команд
 Переполнение стека
 Общественные вопросы и ответы
 Переполнение стека для команд
 Где разработчики и технологи делятся частными знаниями с коллегами
 работы
 Программирование и связанные с ним технические возможности карьерного роста
 Талант
 Нанимайте технических специалистов и создавайте свой бренд работодателя
 реклама
 Обратитесь к разработчикам и технологам со всего мира
 О компании
 .
No related posts.