Инициализация двумерного массива с: Руководство C# | Многомерные массивы

Двумерные массивы в Python — База Знаний Timeweb Community

Иногда нам приходится использовать таблицы с данными для решения своих задач. Такие таблицы называются матрицами или двумерными массивами.

В Python подобные таблицы можно представить в виде списка, элементы которого являются другими списками. Для примера создадим таблицу с тремя столбцами и тремя строками, заполненными произвольными буквами:

mas = [['й', 'ц', 'у'], ['к','е','н'], ['г', 'ш', 'щ']] 
#Вывод всего двумерного массива 
print(mas) 
#Вывод первого элемента в первой строке 
print(mas[0][0]) # Выведет й 
#Вывод третьего элемента в третьей строке 
print(mas[2][2]) # Выведет щ 

Создание двумерных массивов

Создать такой массив в Python можно разными способами. Разберем первый:

# Создание таблицы с размером 3x3, заполненной нулями
a = 3           
mas = [0] * a 
for i in range(a): 
    mas[i] = [0] * a 
print(mas) # Выведет [[0, 0, 0], [0, 0, 0], [0, 0, 0]]     

Второй способ предполагает создание пустого списка с добавлением в него новых списков.

Рассмотрим на примере:

# Создание таблицы с размером 2x2, заполненной единицами

a = 2
mas = [] 
for i in range(a): 
    mas.append([0] * a)
print(mas) # Выведет [[1, 1, 1], [1, 1, 1], [1, 1, 1]]                                 

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

# Создание таблицы с размером 3x3, заполненной двойками
a = 3
mas = [[2] * a for i in range(a)]
print(mas) # Выведет [[2, 2, 2], [2, 2, 2], [2, 2, 2]]

Комьюнити теперь в Телеграм

Подпишитесь и будьте в курсе последних IT-новостей

Подписаться

Способы ввода двумерных массивов

Допустим, нам нужно ввести двумерный массив после запуска нашей программы. Для этого мы можем создать программу, которая будет построчно считывать значения нашего массива, а также количество строк в нем. Рассмотрим на примере:

a=int(input())
mas = [] 
for i in range(a): 
    mas.append(list(map(int, input().split())))
print(mas) 

Запускаем программу и сначала вводим количество строк в массиве (допустим, 3). Далее вводим строки в порядке их очереди. Например:

1 1 1
1 1 1
1 1 1

После этого данная программа выведет наш двумерный массив: [[1, 1, 1], [1, 1, 1], [1, 1, 1]].

То же самое можно сделать с помощью генератора двумерных массивов:

mas = [list(map(int, input().split())) for i in range(int(input()))]
# Вводим 
3
1 1 1
1 1 1
1 1 1
print(mas) # Выведет [[1, 1, 1], [1, 1, 1], [1, 1, 1]]

Вывод двумерных массивов

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

mas = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
for i in range(0, len(mas)):
    for i2 in range(0, len(mas[i])):
        print(mas[i][i2], end=' ')
    print()
# Выведет
1 1 1
1 1 1
1 1 1

То же самое можно сделать не по индексам, а по значениям массива:

mas = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
for i in mas: 
    for i2 in i: 
        print(i2, end=' ') 
    print()
# Выведет
1 1 1
1 1 1
1 1 1

Способ с использованием метода join():

mas = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
for i in mas: 
    print(' '.  join(list(map(str, i))))
# Выведет
1 1 1
1 1 1
1 1 1

Вывод одной из строк двумерного массива можно осуществить с помощью цикла и того же метода join(). Для примера выведем вторую строку в произвольном двумерном массиве:

mas = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
string = 2
for i in mas[string-1]:
    print(i, end=' ')
# Выведет 1 1 1

Для вывода определенного столбца в двумерном массиве можно использовать такую программу:

mas = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
column = 2
for i in mas:
    print(i[column-1], end=' ')
# Выведет 2 5 8

Обработка двумерных массивов

Составим произвольный двумерный массив с числами и размерностью 4×4:

2 4 7 3
4 5 6 9
1 0 4 2
7 8 4 7

Теперь поставим числа в каждой строке по порядку:

mas = [[2, 4, 7, 3], [4, 5, 6, 9], [1, 0, 4, 2], [7, 8, 4, 7]]
mas2 = []
for i in mas:
    mas2.
  append(sorted(i))
print(mas2)
# Выведет [[2, 3, 4, 7], [4, 5, 6, 9], [0, 1, 2, 4], [4, 7, 7, 8]]

А теперь расставим все числа по порядку, вне зависимости от их нахождения в определенной строке:

mas = [[2, 4, 7, 3], [4, 5, 6, 9], [1, 0, 4, 2], [7, 8, 4, 7]]
mas2 = []
for i in mas:
    for i2 in i:
        mas2.append(i2)
mas=sorted(mas2)
for x in range(0, len(mas), 4):
    e_c = mas[x : 4 + x]
    if len(e_c) < 4:
        e_c = e_c + [None for y in range(n - len(e_c))]
    print(list(e_c))
# Выведет
[0, 1, 2, 2]
[3, 4, 4, 4]
[4, 5, 6, 7]
[7, 7, 8, 9]

Итог

Мы разобрались в основах двумерных массивов в Python, научились создавать, вводить и выводить их, а также рассмотрели примеры обработки. Надеюсь, статья оказалась полезной для вас!

НОУ ИНТУИТ | Лекция | Двумерные массивы: задачи поиска, замены и суммирования элементов двумерного массива

< Лекция 13 || Лекция 14: 1234 || Лекция 15 >

Аннотация: В лекции рассматриваются понятие, определение, объявление, инициализация, генерация и вывод двумерных массивов, расположение в памяти элементов массивов, связь между указателями и двумерными массивами, типовые алгоритмы поиска, замены и суммирования в двумерных массивах.

Ключевые слова: вывод, синтаксис, спецификатор, идентификатор, размерность массива, выражение, формальный параметр, целый тип, фигурные скобки, инициализация, индекс, переменная, массив, адрес, двумерный массив, одномерный массив, константы, определение, байт, распределение памяти, ptr, параметр, цикла, представление, структурированные типы данных, операция sizeof, указание типа, алгоритм, входные данные, диапазон, числовой тип

Цель лекции: изучить понятия, особенности внутреннего представления способы генерации и вывода многомерных массивов, научиться выполнять объявление, инициализацию, генерацию и вывод двумерных массивов, использование алгоритмов поиска, замены и суммирования в двумерных массивах при решении задач на языке C++.

Двумерные массивы, являющиеся упорядоченными однотипными объектами, можно отождествлять с прямоугольной матрицей.

intuit.ru/2010/edi»>Двумерные массивы состоят из строк и столбцов.

Объявление двумерных массивов

Синтаксис определения массива без дополнительных спецификаторов и модификаторов имеет два формата:

Тип ИмяМассива[ВыражениеТипаКонстанты][ВыражениеТипаКонстанты];

или

Тип ИмяМассива[][];

ИмяМассива – идентификатор массива.

Тип – тип элементов объявляемого массива. Элементами массива не могут быть функции, файлы и элементы типа void.

ВыражениеТипаКонстанты – задает количество элементов (размерность) массива. Выражение константного типа вычисляется на этапе компиляции. Данное константное выражение может быть опущено в случаях если:

• при объявлении массив инициализируется;
• intuit.ru/2010/edi»>массив объявлен как формальный параметр функции;
• массив объявлен как ссылка на массив, явно определенный в другом файле.

Например:

1. int a[100][50];//массив из 100×50 элементов целого типа
2. double d[4][10];// массив из 4×10 элементов типа double

3. int t=5, k=8;
   float wer[2*t+k][2*t+k]; 
   //массив из (2*t+k)x(2*t+k) элементов вещественного типа

4. int sample[853][157]; 
   //массив из 853 строк  и 157 столбцов, элементы типа int

   равносильно объявлению

   const int N_max=853,
         int M_max=157;
   int sample[N_max][M_max];

   равносильно объявлению

   #define N_max 853
   #define M_max 157
   ...
   int sample[N_max][M_max];

intuit.ru/2010/edi»>Двумерные массивы располагаются в памяти в порядке быстрого изменения последнего индекса. Так, например, данные двумерного массива (состоящего из 3 строк и 10 столбцов и определенного как float A[3][10]; ), располагаются следующим образом:

Строки	Столбцы
	1	2…9
1	A[0][0]	A[0][1] … A[0][9]
2	A[1][0]	A[1][1] … A[1][9]
3	A[2][0]	A[2][1] … A[2][9]

Инициализация двумерных массивов

intuit.ru/2010/edi»>Двумерные массивы инициализируются так же, как и одномерные.

Например:

int w[3][3]={ 
//инициализируется целочисленный массив размерностью 3x3
                {2, 3, 4}, //1-я строка
                {3, 4, 8}, //2-я строка
                {1, 0, 9} //3-я строка
               };
float w[2][3]={ 
//инициализируется вещественный массив размерностью 2x3
                {2.1, 3.4, 4.5}, //1-я строка
                {5.0, 6.4, 3.9} //2-я строка
               };

равносильно инициализации

float w[][3]={ 
                {2.1, 3.4, 4.5}, //1-я строка
                {5.0, 6.4, 3.9} //2-я строка
               };

Последовательности, выделенные в фигурные скобки, соответствуют строкам массива, в случае отсутствия скобок инициализация будет выполнена неправильно.

int w[3][5]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

1	2	3	4	5
6	7	8	9	10
11

int w[3][5]={{1, 2, 3}, {4, 5, 6, 7, 8}, {9, 10, 11}};

1	2	3
4	5	6	7	8
9	10	11

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

intuit.ru/2010/edi»>Обращение к элементам двумерного массива осуществляется так же, как и к элементам одномерного.

ИмяМассива[ВыражениеТипаКонстанты][ВыражениеТипаКонстанты];

или

ИмяМассива[ЗначениеИндекса][ЗначениеИндекса];

Например:

a[0][0] – индекс задается как константа,

d[55][5] – индекс задается как константа,

s[i][j] – индекс задается как переменная,

w[4*p][3+t] – индекс задается как выражение.

Дальше >>

< Лекция 13 || Лекция 14: 1234 || Лекция 15 >

6 способов объявить и инициализировать двумерный (2D) строковый и целочисленный массив в Java например,

Структуры данных и алгоритмы: глубокое погружение с использованием Java на Udemy.

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

Теперь давайте рассмотрим несколько способов объявления двумерного массива в Java, чтобы лучше понять концепцию.

Что касается Java, вы всегда должны помнить, что нет ничего похожего на двумерный массив, по сути, это просто массив одномерного массива. Это ключ к написанию алгоритма, включающего многомерные массивы, например циклический просмотр двумерного массива, поиск элементов и т. д.

Теперь, когда вы знаете, что такое двумерный или двумерный массив в Java, давайте рассмотрим пару примеров. как создать и инициализировать двумерный массив . Я выбрал как массивы int, так и массивы String, поскольку они являются наиболее распространенным типом массива, который вы встретите при программировании.

1. Объявить двумерный массив с обоими измерениями

Наш первый пример касается объявления двумерного массива с обоими измерениями. Давайте объявим однородный двумерный массив, следующим будет двумерный массив целых чисел с 3 строками и 2 столбцами, а затем — двумерный массив строк с 4 строками и 3 столбцами:

 int[][] squares = new int[3] [2];
String[][] cubes = новая строка[4][3]; 

2. Объявление двумерного массива всего с одним измерением

В Java вы можете объявить двумерный массив только с одним измерением, но это должно быть первое измерение. Оставление обоих измерений или первого измерения при объявлении массива является недопустимым в Java и вызывает ошибку времени компиляции, как показано ниже:

 int[][] numbers = new int[][] ; // ошибка - обязательно первое измерение
int[][] primes = new int[][2] ; // ошибка - обязательно первое измерение
int[][] multipliers = new int[10][]; // хорошо, второе измерение опционально
Строка[][] имена = новая строка[5][]; 

Кстати, если вы новичок и не знакомы с синтаксисом массивов в Java или хотите узнать больше о языке программирования Java, я также предлагаю вам пройти всеобъемлющий курс Java, такой как The Complete Java MasterClass на Udemy. Это также самый современный курс по Java, который всегда обновляется, чтобы охватить последнюю версию Java.

3. Положение квадратной скобки

Вы также можете поменять местами квадратные скобки при объявлении массива в Java, как показано в следующем примере кода:

 int[] quotes[] = new int[2][2]; // хорошо 

Важно отметить, что в этом коде кавычки — это не двумерный массив, а просто одномерный массив. На самом деле мы объявили только int[]

Еще одна вещь, которую следует помнить об этом коде, заключается в том, что если несколько переменных объявлены в одной строке, они будут иметь тип int[], который является одномерным, а не двумерным, как в следующем примере. цены — это двумерный массив, но abc — это просто одномерный массив целых чисел.

 int[] цены[], abc; 

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

4. Другой пример с положением квадратной скобки

Также можно поставить обе квадратные скобки после имени переменной, как в следующем объявлении номер переменной int, a — одномерный массив int, а b — двумерный массив int.

 целое число, a[], b[][]; 

Если вы все еще в замешательстве, я предлагаю вам взглянуть на Основы Java, часть 1 и часть 2 в Pluralsight, двух углубленных курсах по Java на Pluralsight.

5. 2D массив с переменной длиной столбца

Например, создание двумерного массива, в котором каждый массив имеет разную длину, в следующем коде идентификаторы содержат три одномерных массива целых чисел, каждый из которых имеет разную длину, т. е. 10, 20 и 30

 int[][] ids = new int[3][ ];
идентификаторы [0] = новый интервал [10];
идентификаторы [1] = новый интервал [20];
идентификаторы [2] = новый интервал [30]; 

6. Объявление и инициализация гетерогенного двумерного массива

Создание разнородного 2D-массива в Java. В гетерогенном массиве каждый подмассив имеет разный тип, как в следующем примере, подмассив элементов имеет тип Integer, String и Float.

 Object[][] items = new String[3][];
элементы [0] = новое целое число [] {1, 2, 4};
items[1] = new String[]{"a", "b"};
элементы[2] = новый Float[]{1.0f, 2.0f}; 

Вот краткий обзор различных способов объявления двумерного массива в Java:

Это все о 6 различных способах объявления двумерного массива в Java . Вы можете видеть, что 2D-массив предлагает большую гибкость и мощность, например. вы можете объявить двумерный массив без указания второго измерения, вы можете объявить двумерный массив, в котором каждый подмассив имеет разную длину, и вы даже можете создать гетерогенный двумерный или двумерный массив в Java.

Связанные Структура данных и алгоритм Вопросы интервью из блога Javarevisited

• 30 лучших вопросов интервью по кодированию массивов с ответами (см. здесь)
• Как найти пропущенное число в массиве? (ответ)
• Как сравнить два массива в Java? (ответ)
• Как перевернуть массив на месте в Java? (раствор)
• 15 основных вопросов о структуре данных и алгоритмах интервью (см. здесь)
• Топ-20 вопросов на собеседовании по строковому кодированию (см. здесь)
• Как удалить повторяющиеся элементы из массива в Java? (решение)
• Как найти все пары, сумма которых равна заданному числу в Java (решение)
• Топ-30 вопросов для собеседования по кодированию со связанным списком (см. здесь)
• 50 лучших Java-программ по результатам интервью по программированию (см. здесь)
• 5 Бесплатные курсы по структуре данных и алгоритмам для программистов (курсы)
• 10 книг по алгоритмам, которые должен прочитать каждый программист (книги)
• 50+ Структура данных и алгоритмы Проблемы из интервью (вопросы)
• 10 Бесплатные курсы по структуре данных и алгоритмам для программистов (курсы)
• Более 100 проблем кодирования структуры данных из интервью (вопросы)

Спасибо, что прочитали эту статью. Если вам понравился этот учебник и пример массива Java, поделитесь им с друзьями и коллегами. Если у вас есть какие-либо вопросы или сомнения, сообщите нам об этом, и я постараюсь найти для вас ответ. Как всегда, приветствуются предложения, комментарии, инновационные и лучшие ответы.

P. S. . Если вы ищете бесплатные курсы по алгоритмам, чтобы улучшить свое понимание структуры данных и алгоритмов, вам также следует проверить 9Курс 0003 Easy to Advanced Data Structures на Udemy. Он создан инженером-программистом Google и экспертом по алгоритмам и совершенно бесплатен.

python — Как определить двумерный массив?

Задавать вопрос

спросил 11 лет, 8 месяцев назад

Изменено 5 месяцев назад

Просмотрено 2,9 млн раз

Я хочу определить двумерный массив без инициализированной длины следующим образом:

 Matrix = [][]
 

Но выдает ошибку:

IndexError: индекс списка вне допустимого диапазона

• python
• список
• многомерный массив

3

Технически вы пытаетесь индексировать неинициализированный массив. Вы должны сначала инициализировать внешний список списками перед добавлением элементов; Python называет это «понимание списка».

 # Создает список, содержащий 5 списков, каждый из 8 элементов, все установлены на 0
ш, ч = 8, 5
Матрица = [[0 для x в диапазоне (w)] для y в диапазоне (h)]
 

#Теперь вы можете добавлять элементы в список:

 Matrix[0][0] = 1
Matrix[6][0] = 3 # ошибка! диапазон...
Matrix[0][6] = 3 # действительно
 

Обратите внимание, что матрица является старшим адресом «y», другими словами, «индекс y» предшествует «индексу x».

 print Matrix[0][0] # отпечатков 1
х, у = 0, 6
print Matrix[x][y] # печатает 3; будьте осторожны с индексацией!
 

Хотя вы можете называть их как хотите, я смотрю на это таким образом, чтобы избежать некоторой путаницы, которая может возникнуть при индексации, если вы используете «x» как для внутреннего, так и для внешнего списков и хотите неквадратную матрицу.

14

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

 >>> import numpy
>>> numpy.zeros ((5, 5))
массив([[ 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [ 0., 0., 0., 0., 0.]])
 

Вот несколько других способов создания двумерных массивов и матриц (с удаленным выводом для компактности):

 numpy.arange(25).reshape((5, 5)) # создать одномерный диапазон и изменить форму
numpy.array(range(25)).reshape((5, 5)) # передать диапазон Python и изменить форму
numpy.array([5] * 25).reshape((5, 5)) # передать список Python и изменить форму
numpy.empty((5, 5)) # размещаем, но не инициализируем
numpy.ones((5, 5)) # инициализируем единицами
 

numpy также предоставляет тип матрицы , но он больше не рекомендуется для любого использования и может быть удален из numpy в будущем.

7

Вот более короткая запись для инициализации списка списков:

 матрица = [[0]*5 для i в диапазоне (5)]
 

К сожалению, сокращение до чего-то вроде 5*[5*[0]] на самом деле не работает, потому что вы получаете 5 копий одного и того же списка, поэтому, когда вы изменяете одну из них, они все меняются, например:

 >>> матрица = 5*[5*[0]]
>>> матрица
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [ 0, 0, 0, 0, 0]]
>>> матрица[4][4] = 2
>>> матрица
[[0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [ 0, 0, 0, 0, 2]]
 

11

Если вы хотите создать пустую матрицу, правильный синтаксис:

 matrix = [[]]
 

И если вы хотите создать матрицу размера 5, заполненную 0,

 матрица = [[0 для i в xrange(5)] для i в xrange(5)]
 

3

Если все, что вам нужно, это двумерный контейнер для хранения некоторых элементов, вместо этого вы можете удобно использовать словарь:

 Matrix = {}
 

Тогда вы можете сделать:

 Matrix[1,2] = 15
печатать Матрица[1,2]
 

Это работает, потому что 1,2 — это кортеж, и вы используете его как ключ для индексации словаря. Результат подобен тупой разреженной матрице.

Как указали osa и Josap Valls, вы также можете использовать Matrix = collections.defaultdict(lambda:0) , чтобы отсутствующие элементы имели значение по умолчанию 0 .

Ватсал далее указывает, что этот метод, вероятно, не очень эффективен для больших матриц и должен использоваться только в некритичных к производительности частях кода.

6

В Python вы будете создавать список списков. Вам не нужно объявлять размеры заранее, но вы можете. Например:

 матрица = []
матрица.дополнение([])
матрица.дополнение([])
матрица [0].append(2)
матрица[1].append(3)
 

Теперь матрица[0][0] == 2 и матрица[1][0] == 3. Вы также можете использовать синтаксис понимания списка. В этом примере он используется дважды для построения «двумерного списка»:

 из счетчика импорта itertools, takewhile
матрица = [[i для i в takewhile (лямбда j: j < (k + 1) * 10, count (k * 10))] для k в диапазоне (10)]
 

1

Вот код для новичка, который пришел из C, CPP и Java background

 строк = целое (ввод ())
столбцы = интервал (ввод ())
матрица = []
для я в диапазоне (строки):
  строка = []
  для j в диапазоне (столбцы):
    строка. добавлять(0)
  matrix.append(строка)
печать (матрица)
 

Почему такой длинный код, который тоже в Python спросите вы?

Давным-давно, когда мне не нравился Python, я увидел однострочные ответы для написания 2D-матрицы и сказал себе, что больше не буду использовать 2-D матрицу в Python. (Эти отдельные строки были довольно пугающими, и они не дали мне никакой информации о том, что делает Python. Также обратите внимание, что я не знаю об этих сокращениях.)

0

Принятый ответ хороший и правильный, но мне потребовалось некоторое время, чтобы понять, что я также могу использовать его для создания совершенно пустого массива.

 л = [[] для _ в диапазоне (3)]
 

приводит к

 [[], [], []]
 

0

Вы должны составить список списков, и лучше всего использовать вложенные включения:

 >>> matrix = [[0 для i в диапазоне (5)] для j в диапазоне (5)]
>>> pprint. pprint(матрица)
[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]
 

В вашем примере [5][5] вы создаете список с целым числом «5» внутри и пытаетесь получить доступ к его 5-му элементу, и это, естественно, вызывает IndexError, потому что 5-го элемента нет:

 >>> л = [5]
>>> л[5]
Traceback (последний последний вызов):
  Файл "", строка 1, в 
IndexError: индекс списка вне допустимого диапазона
 

1

Использование:

 матрица = [[0]*5 для i в диапазоне (5)]
 

*5 для первого измерения работает, потому что на этом уровне данные неизменяемы.

1

Так я обычно создаю 2D-массивы в Python.

 цв = 3
ряд = 4
массив = [[0] * столбец для _ в диапазоне (строка)]
 

Я нахожу этот синтаксис легко запоминающимся по сравнению с использованием двух циклов for при анализе списка.

Переписать для удобства чтения:

 # 2D массив/матрица
# 5 рядов, 5 столбцов
количество_строк = 5
cols_count = 5
# создавать
# создание выглядит наоборот
# создать массив столбцов "cols_count" для каждой из строк "rows_count"
# все элементы инициализируются 0
two_d_array = [[0 для j в диапазоне (cols_count)] для i в диапазоне (rows_count)]
# индекс от 0 до 4
# для строк и столбцов
# начиная с 5 строк, 5 столбцов
# использовать
two_d_array[0][0] = 1
print two_d_array[0][0] # печатает 1 # 1-я строка, 1-й столбец (верхний левый элемент матрицы)
two_d_array[1][0] = 2
print two_d_array[1][0] # печатает 2 # 2-я строка, 1-й столбец
two_d_array[1][4] = 3
print two_d_array[1][4] # печатает 3 # 2-я строка, последний столбец
two_d_array[4][4] = 4
print two_d_array[4][4] # печатает 4 # последняя строка, последний столбец (справа, нижний элемент матрицы)
 

0

Объявить матрицу нулей (единиц):

 numpy. zeros((x, y))
 

напр.

 >>> numpy.zeros ((3, 5))
    массив([[ 0., 0., 0., 0., 0.],
   [0., 0., 0., 0., 0.],
   [ 0., 0., 0., 0., 0.]])
 

или numpy.ones ((х, у)) например

 >>> np.ones((3, 5))
массив([[ 1., 1., 1., 1., 1.],
   [1., 1., 1., 1., 1.],
   [ 1., 1., 1., 1., 1.]])
 

Возможны даже три измерения. (http://www.astro.ufl.edu/~warner/prog/python.html см. --> Многомерные массивы)

Вы можете создать пустой двумерный список, вложив две или более квадратных скобок или третью скобку ( [] , разделенные запятой) с квадратной скобкой, как показано ниже:

 Matrix = [[], []]
 

Теперь предположим, что вы хотите добавить 1 к Matrix[0][0] , затем введите:

 Matrix[0].append(1)
 

Теперь введите Matrix и нажмите Enter. Результат будет:

 [[1], []]
 

Если вы ввели следующий оператор вместо

 Matrix[1].append(1)
 

, тогда Матрица будет

 [[], [1]]
 

Я работаю над своим первым скриптом Python, и меня немного смутил пример с квадратной матрицей, поэтому я надеюсь, что приведенный ниже пример поможет вам сэкономить время:

 # Создает матрицу 2 x 5
 Матрица = [[0 для y в xrange(5)] для x в xrange(2)]
 

, так что

 Matrix[1][4] = 2 # Действительно
Matrix[4][1] = 3 # IndexError: индекс списка вне допустимого диапазона
 

Используя NumPy, вы можете инициализировать пустую матрицу следующим образом:

 импортировать numpy как np
мм = np. matrix([])
 

А позже добавьте данные следующим образом:

 мм = np.append(мм, [[1,2]], ось=1)
 

1

Я читаю файлы, разделенные запятыми, следующим образом:

 data=[]
для l в файле:
    л = разделить (',')
    data.append(l)
 

Список "данные" является списком списков с индексом data[row][col]

0

Вот для чего создан словарь

!

 матрица = {}
 

---

Вы можете определить ключи и значения двумя способами:

 матрица[0,0] = значение
 

или

 матрица = {(0,0) : значение}
 

Результат:

 [значение, значение, значение, значение, значение],
   [значение, значение, значение, значение, значение],
   ...
 

Использование:

 импортная копия
def ndlist(*args, init=0):
    дп = инициализация
    для x в обратном (аргументы):
        dp = [copy. deepcopy(dp) для _ в диапазоне(x)]
    вернуть дп
l = ndlist(1,2,3,4) # 4-х мерный список, инициализированный нулями
л[0][1][2][3] = 1
 

Я думаю, NumPy — это то, что нужно. Вышеприведенное является общим, если вы не хотите использовать NumPy.

1

Если вы хотите иметь возможность думать об этом как о двумерном массиве, а не думать как о списке списков (на мой взгляд, гораздо более естественно), вы можете сделать следующее:

 import numpy
Nx=3; Ню=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()
 

Результатом является список (не массив NumPy), и вы можете перезаписывать отдельные позиции числами, строками и т. д.

1

 l=[[0]*(L) для _ в диапазоне(W)]
 

Будет быстрее, чем:

 l = [[0 для x в диапазоне (L)] для y в диапазоне (W)]
 

1

Если перед запуском у вас нет информации о размере, создайте два одномерных списка.

 список 1: для хранения строк
список 2: Фактическая двумерная матрица
 

Сохранить всю строку в 1-м списке. После этого добавьте список 1 в список 2:

 из случайного импорта randint
координаты=[]
темп=[]
points=int(raw_input("Введите количество координат >"))
для i в диапазоне (0, баллы):
    случайный x = случайный (0,1000)
    случайный = случайный (0,1000)
    темп=[]
    temp.append(randomx)
    temp.append(случайный)
    координаты.append(temp)
распечатать координаты
 

Вывод:

 Введите количество координат >4
[[522, 96], [378, 276], [349, 741], [238, 439]]
 

с помощью списка:

 matrix_in_python = [['Рой',80,75,85,90,95],['Джон',75,80,75,85,100],['Дэйв',80,80,80,90,95]]
 

с помощью dict: вы также можете сохранить эту информацию в хэш-таблице для быстрого поиска, например

 matrix = { '1':[0,0] , '2':[0,1],'3':[0,2],' 4' : [1,0],'5':[1,1],'6':[1,2],'7':[2,0],'8':[2,1],' 9':[2,2]};
 

matrix['1'] даст вам результат за время O(1)

*nb : вам нужно справиться с коллизией в хеш-таблице

 # Создает список, содержащий 5 списков, инициализированных до 0
Матрица = [[0]*5]*5
 

Будьте осторожны с этим коротким выражением, см. полное объяснение в ответе @F.J

6

Вот фрагмент кода для создания матрицы в Python:

 # получить входные строки и столбцы
строки = интервал (ввод ("строки:"))
cols = int(input("Cols : "))
# инициализируем список
l=[[0]*столбцы для i в диапазоне (строки)]
# заполняем его случайными значениями
для я в диапазоне (0, строки):
    для j в диапазоне (0, столбцы):
        л [я] [j] = я + j
# распечатать список
для я в диапазоне (0, строки):
    Распечатать()
    для j в диапазоне (0, столбцы):
        распечатать (л [я] [j], конец = " ")
 

Пожалуйста, подскажите, если я что-то пропустил.

Обычно переходным модулем является NumPy:

 импортировать numpy как np
   
# Генерируем случайную матрицу чисел с плавающей запятой
np.random.rand (столбцы, строки)
# Генерируем случайную матрицу целых чисел
np.random.randint (1, 10, размер = (столбцы, строки))
 

Попробуйте так:

 строк = int(input('Введите строки\n'))
мой_список = []
для я в диапазоне (строки):
    my_list. append(список(карта(int, input().split())))
 

Если вам нужна матрица с предопределенными номерами, вы можете использовать следующий код:

 матрица определения (строки, столбцы, начало = 0):
    return [[c + start + r * cols для c в диапазоне (столбцы)] для r в диапазоне (строки)]
утверждать матрицу (2, 3, 1) == [[1, 2, 3], [4, 5, 6]]
 

Пользовательская функция для ввода матрицы и печати

 def inmatrix(m,n):
 #Запустить функцию и передать строку и столбец в качестве параметра
 a=[] #создать пустую матрицу
 для i в диапазоне (м): # Row input
 b=[]#пустой список
 для j в диапазоне (n): # ввод столбца
 elm=int(input("Введите число в Pocket ["+str(i)+"]["+str(j)+"] ")) #Показать номер строки и столбца
 b.append(elm) # добавить значение в список b
 a.append(b)# Добавить список в матрицу
 вернуть матрицу #return
def Matrix(a): #функция для матрицы печати
 для i в диапазоне (len (a)): #row
 для j в диапазоне (len (a [0])): # столбец
 print(a[i][j],end=" ") #вывести значение с пробелом
 print()#печатать строку После печати строки
m=int(input("Введите номер строки")) #input row
n=int(input("Введите номер столбца"))
a=inmatrix(m,n) #вызвать входную матричную функцию
print("Матрица это.
No related posts.