Как преобразованить двумерный список в одномерный?
Преобразовать одномерный список в двумерный
Дано: l — "простой" список, obj — атом. Сформировать списки из заданного obj с каждым .
Как преобразовать двумерный список строк целых чисел в двумерный список просто целых чисел?
"Напишите программу, на вход которой подаётся прямоугольная матрица в виде последовательности.
двумерный вывести как одномерный
Подскажите, пожалуйста, как в паскале двумерный массив вывести в виде одномерного и обратно
Как одномерный массив преобразовать в двумерный
#define _CRT_SECURE_NO_WARNINGS #include <stdlib.h> #include <stdio.h> #include <conio.h>.
Как перевести двумерный массив в одномерный?
Как сформулировать одномерный массив из положительных элементов двумерного массива? Я написал код.
Автоматизируй это!
7059 / 4562 / 1209
Регистрация: 30.03.2015
Сообщений: 13,142
Записей в блоге: 29
Сообщение было отмечено nikki4 как решение
Решение
nikki4, ну блин по питону ничего не читаешь, не изучаешь?
1 2 3 4 5 6 7 8 9 10
>>> lst=['abc',['d', 'e'],['f', 'g']] >>> result=[] >>> for e in lst: . if type(e) is list: . result+=e . else: . result.append(e) . >>> result ['abc', 'd', 'e', 'f', 'g']
4459 / 3212 / 1125
Регистрация: 21.03.2016
Сообщений: 7,949
1 2 3 4 5 6 7 8 9 10 11
def fun(lst, result = []): for i in lst: if isinstance(i,list): fun(i, result) else: result.append(i) return result lst=['abc',['d', 'e'],['f', 'g',[1,2,3]]] print(fun(lst))
4615 / 2036 / 359
Регистрация: 17.03.2012
Сообщений: 10,103
Записей в блоге: 6
1 2 3 4 5 6 7 8 9
def flatten(sequence): if type(sequence) is list: for itm in sequence: yield from flatten(itm) else: yield sequence obj = [[1,2, [3,4]], 5, 6] print(list(flatten(obj)))
(на 2-м работать не будет, там нет yield from)
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
Помогаю со студенческими работами здесь
Как преобразовать одномерный массив в двумерный?
Есть масcив типа ABCDEFG нужно чтобы каждый пятый элемент начинался с новой строки ABCDE FG Как.
Как перевести одномерный массив в двумерный?
Привет) В общем задача такая: Задать не простое число L. Найти 2 числа L1 и L2, произведение.
Как переконвертировать двумерный массив в одномерный
Здравствуйте! Подскажие пожалуйста, как из двумерного массива mas получить одномерный к примеру x
Как превратить двумерный массив в одномерный?
Здравствуйте! Прошу помощи. Не знаю, как исправить код ниже для Эксель, чтобы одномерный массив.
Как узнать, массив одномерный или двумерный?
Есть ли простая функция? Если нет — то как это сделать на циклах?
Программирование в «Эврике»
Теперь мы можем присваивать каждому элементу списка 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],
Объединение и разделение массивов
На предыдущем занятии мы познакомились со способами изменения форм массивов. Здесь мы узнаем как реализуются операции объединения и разделения массивов. Для этой задачи в NumPy реализованы специальные функции, которые мы сейчас и рассмотрим.
Функции hstack и vstack
Предположим у нас есть два двумерных массива:
a = np.array([(1, 2), (3, 4)]) b = np.array([(5, 6), (7, 8)])
Их можно объединить как по горизонтали, так и по вертикали, с помощью функций:
np.hstack([a, b]) # объединение по оси axis1 (размерность 2x4) np.vstack([a, b]) # объединение по оси axis0 (размерность 4x2)
Примеры работы этих двух функций представлены на рисунке ниже:
Эти же операции можно выполнять и с многомерными массивами. Например, определим два трехмерных массива:
a = np.fromiter(range(18), dtype='int32') b = np.fromiter(range(18, 36), dtype='int32') a.resize(3, 3, 2) b.resize(3, 3, 2)
И выполним функции:
c = np.hstack([a, b]) # размерность 3x6x2 d = np.vstack([a, b]) # размерность 6x3x2
Как видите, здесь произошло формальное объединение по оси axis1 в функции hstack и по оси axis0 в функции vstack.
Разумеется, чтобы эти функции работали, размерность массивов по объединяемым осям должны совпадать.
Аналогичным образом происходит объединение и одномерных массивов:
a = np.fromstring('1 2 3 4', sep = ' ') b = np.fromstring('5 6 7 8', sep = ' ')
И при выполнении:
np.hstack([a, b])
array([1., 2., 3., 4., 5., 6., 7., 8.])
А во втором случае:
np.vstack([a, b])
результатом будет двумерный массив:
Функции column_stack и row_stack
Давайте теперь зададимся вопросом: как объединить наши два одномерных массива столбцами? Чтобы результат выглядел вот так:
Для этого хорошо подходит функция column_stack():
np.column_stack([a, b]) # формирование массива 4x2
Если с ее помощью объединять двумерные и многомерные массивы, то она будет давать тот же результат, что и функция hstack().
Другая аналогичная функция row_stack(), в принципе, делает то же самое, что и функция vstack() заметных отличий здесь нет. Ее можно использовать так:
np.row_stack([a, b]) # матрица 2x4
Функция concatenate
Для объединения массивов вдоль строго определенной оси можно воспользоваться функцией concatenate(). Например, возьмем два трехмерных массива:
a = np.arange(1, 13) b = np.arange(13, 26) a.resize(3, 3, 2) b.resize(3, 3, 2)
И объединим их по каждой из осей:
c0 = np.concatenate([a, b], axis=0) # размерность 6x3x2 c1 = np.concatenate([a, b], axis=1) # размерность 3x6x2 c2 = np.concatenate([a, b], axis=2) # размерность 3x3x4
Объекты r_ и c_
Еще один способ объединения и создания массивов – это использование специальных объектов r_ и c_. Например, объект r_ создает копии массивов, следующими способами:
np.r_[ [1, 2, 3], 4, 5] # список + дополнительные элементы np.r_[ 1:9, 90, 100] # срез + два элемента np.r_[ np.array([1,2,3]), np.array([4,5,6])] # объединение двух массивов np.r_[ [(1,2,3), (4,5,6)], [(7,8,9)] ] # объединение двумерного и одномерного списков
По аналогии работает и второй объект c_, только объединение выполняется по второй оси axis1:
np.c_[1:5] np.c_[ [1, 2, 3], [4, 5, 6]] np.c_[ [(1,2,3), (4,5,6)], [[7],[8]] ]
Разделение массивов
Массивы в NumPy можно не только объединять, но и разделять. Для этого существуют специальные функции hsplit и vsplit. Рассмотрим их работу на простых примерах. Пусть имеется одномерный массив из 10 элементов:
a = np.arange(10)
И мы хотим разделить его на две равные части. Это реализуется с помощью функции hsplit:
np.hsplit(a, 2)
которая возвращает список из двух массивов. Второй параметр 2 указывает число частей, на которые делится исходный массив. Причем, деление выполняется по горизонтали. Если в нашем примере указать 3 части, то возникнет ошибка:
np.hsplit(a, 3) # ошибка 10 на 3 нацело не делится
так как 10 элементов нельзя равномерно разбить на 3 части.
Также ошибка будет и при разбиении этого массива по вертикали:
np.vsplit(a, 2) # ошибка: нет вертикальной оси
так как массив имеет одну горизонтальную ось. Чтобы вторая функция сработала, преобразуем массив a в вектор столбец:
a.shape = 10, -1 # вектор-столбец
а, затем, разобьем по вертикали:
np.vsplit(a, 2)
На выходе получим два одномерных массива длиной 5 элементов.
Эти же функции можно использовать и с многомерными массивами, например, так:
a = np.arange(12) a.resize(2, 6) # двумерный массив 2x6 np.hsplit(a, 2) # разбиение по горизонтали np.vsplit(a, 2) # разбиение по вертикали
Функция array_split
Рассмотренные функции выполняют разбиение или по первой оси axis0 или по второй оси axis1. Но что если нам нужно выполнить разбиение по произвольной оси многомерного массива? Для этого существует функция array_split(). Ее работа аналогична рассмотренным выше функциям, только дополнительно указывается ось разбиения. Например:
a = np.arange(18) a.resize(3, 3, 2) np.array_split(a, 2, axis=2) np.array_split(a, 3, axis=0) np.array_split(a, 3, axis=1)
Видео по теме
#1. Пакет numpy — установка и первое знакомство | NumPy уроки
#2. Основные типы данных. Создание массивов функцией array() | NumPy уроки
#3. Функции автозаполнения, создания матриц и числовых диапазонов | NumPy уроки
#4. Свойства и представления массивов, создание их копий | NumPy уроки
#5. Изменение формы массивов, добавление и удаление осей | NumPy уроки
#6. Объединение и разделение массивов | NumPy уроки
#7. Индексация, срезы, итерирование массивов | NumPy уроки
#8. Базовые математические операции над массивами | NumPy уроки
#9. Булевы операции и функции, значения inf и nan | NumPy уроки
#10. Базовые математические функции | NumPy уроки
#11. Произведение матриц и векторов, элементы линейной алгебры | NumPy уроки
#12. Множества (unique) и операции над ними | NumPy уроки
#13. Транслирование массивов | NumPy уроки
© 2023 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Переформатирование, изменение формы — Python: Numpy-массивы
Часто разработчикам приходится изменять размеры массивов. Например, переформатировать исходные данные, чтобы разделить их на подмассивы. В некоторых случаях требуется еще и объединять многомерные данные в единый массив значений. Чтобы решать такие задачи, массивы numpy.ndarray предоставляют набор методов, самым популярным из которых является метод reshape() .
В этом уроке разберем, как работать с размерами массивов numpy.ndarray и как получать их производные. Еще поговорим об ограничениях размерности и узнаем, как они помогают оптимизировать работу.
Как изменить размер массива
Представим, что нам нужно увеличить размер массива numpy.ndarray . Для этого будем идти по следующим шагам:
- Узнаем размер массива и индексы вдоль оси
- Изменим размер массива
Рассмотрим каждый этап подробнее.
Как узнать размер массива и индексы вдоль оси
Чтобы изменить размер numpy.ndarray , нужно узнать его значение. Для этого используют атрибут shape :
import numpy as np one_dimension_array = np.array( [0,1,2,3,4,5,6,7,8,9,10,11] ) print(one_dimension_array.shape) # => (12,) two_dimensions_array = np.array( [ [0,1,2], [3,4,5], [6,7,8], [9,10,11] ] ) print(two_dimensions_array.shape) # => (4, 3) three_dimensions_array = np.array( [ [ [0,1], [2,3], ], [ [4,5], [6,7], ], [ [8,9], [10,11] ] ] ) print(three_dimensions_array.shape) # => (3, 2, 2) В примере выше атрибут shape возвращает кортеж целых чисел. Длина кортежа указывает на размерность массива:
- (12,) — одномерный массив
- (4, 3) — двумерный массив
- (3, 2, 2) — трехмерный массив
Числа в кортеже означают количество элементов по конкретной оси индексов:
- (12,) — 12 значений
- (4, 3) — четыре блока значений по три значения в каждом
- (3, 2, 2) — три блока значений, каждый из которых состоит из двух блоков по два значения
Название ось индексов отсылает к декартовой системе координат. Вспомним ее основные правила:
- Чтобы построить отрезок или другой одномерный объект, достаточно одной координатной оси
- Чтобы построить квадрат или другой двумерный объект, необходима координатная плоскость из двух перпендикулярных осей
- Чтобы построить куб или другой трехмерный объект, нужно три ортогональные оси координат
Теперь, когда мы знаем размер исходного массива, можно изменять его форму. Для этого используем метод reshape() .
Как изменить размер массива с помощью метода reshape()
В Python используется метод reshape() , с помощью которого можно получить двухмерный и трехмерный массив из одномерного. Этот обязательный параметр ожидает новый размер данных, к которому нужно переформатировать исходный массив.
Попробуем получить двумерный массив two_dimensions_array из одномерного массива one_dimension_array . Для этого используем метод reshape() с новым размером данных (4, 3) :
print(one_dimension_array.reshape((4, 3))) # => [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]] Чтобы получить трехмерный массив three_dimensions_array , достаточно также указать нужный размер:
print(one_dimension_array.reshape((3, 2, 2))) # => [[[ 0 1] # [ 2 3]] # [[ 4 5] # [ 6 7]] # [[ 8 9] # [10 11]]] Изменять форму массива можно не только от данных меньшей размерности к данным большей размерности. Это можно делать и в обратную сторону.
Попробуем получить исходный одномерный массив one_dimension_array из двумерного массива two_dimensions_array :
print(two_dimensions_array.reshape((12,))) # => [ 0 1 2 3 4 5 6 7 8 9 10 11] А тут переформатируем three_dimensions_array в two_dimensions_array :
print(three_dimensions_array.reshape((4,3))) # => [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]] Необязательно уменьшать размер последовательно. Например, можно из трехмерного массива получить сразу одномерный:
print(three_dimensions_array.reshape((12,))) # => [ 0 1 2 3 4 5 6 7 8 9 10 11] С помощью атрибута shape можно узнать размерность массива numpy.ndarray . А метод reshape поможет ее уменьшить или увеличить. Однако у этого массива есть ограничения по размеру данных — его нужно соблюдать, чтобы оптимизировать выполнения методов над массивами.
Какие размеры массива допустимы
У массива numpy.ndarray есть ограничения по размеру данных — по осям индексов должны быть данные одного размера. Это ограничение позволяет оптимизировать выполнения методов над массивами. Рассмотрим на примере.
Допустим, нам нужно сконвертировать список из списков длиной три и два:
np.array( [ [0,1,2], [3,4,], ] ) # => [list([0, 1, 2]) list([3, 4])] На первый взгляд у нас получился массив numpy.ndarray . Но если внимательно посмотреть на элементы, мы увидим, что получились списки, а не ожидаемые целочисленные массивы. Это ограничит дальнейшую работу с данными, потому что поведение многих методов меняется.
Попробуем найти в данном массиве максимальный элемент 4 . Это приведет к такому результату:
print(np.array( [ [0,1,2], [3,4,], ] ).max()) # => [3, 4] В этом примере мы получили не тот результат, которого ожидали.
Numpy старается предотвращать некорректные действия — для этого в нем есть система предупреждений и подсказок. Но это не значит, что не нужно следить за размером массива. Он играет важную роль в реализации методов библиотеки Numpy, поэтому рекомендуем обращать внимание на этот момент.
В случае с методом reshape() Numpy вообще не дает совершить некорректную конвертацию массива из 12 элементов в массив из 15 элементов — три блока по пять значений. В этом случае он вызывает исключение:
one_dimension_array.reshape(3,5) # => ValueError: cannot reshape array of size 12 into shape (3,5) Ограничения по размеру могут добавить неудобств, когда мы увеличиваем или уменьшаем размерность массива. При этом они позволяют не указывать некоторые значения размера, когда мы хотим его изменить.
Как сделать автоматический расчет размера массива
Ограничения на размер массива позволяют не указывать некоторые размеры в методе reshape() . Это можно оставить на автоматический расчет. Для этого нужное значение размерности поменяем на -1 :
print(one_dimension_array.reshape((4,3))) print(one_dimension_array.reshape(((4, -1)))) print(one_dimension_array.reshape(((-1, 3)))) # => [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]] Все преобразования в примере выше дают одинаковый результат. Необходимый размер рассчитывается автоматически, исходя из количества элементов.
Для массивов большей размерности это работает по такому же принципу:
print(one_dimension_array.reshape((3, 2, 2))) print(one_dimension_array.reshape((-1, 2, 2))) print(one_dimension_array.reshape((3, -1, 2))) print(one_dimension_array.reshape((3, 2, -1))) # => [[[ 0 1] # [ 2 3]] # [[ 4 5] # [ 6 7]] # [[ 8 9] # [10 11]]] Чтобы получить одномерный массив и использовать автоматический расчет, не нужно находить количество элементов. Строки в примере ниже дают одинаковый результат:
print(three_dimensions_array.reshape((12,))) print(three_dimensions_array.reshape((-1,))) # => [ 0 1 2 3 4 5 6 7 8 9 10 11] Теперь вы знаете, как определять размерность массива. Вы умеете изменять размер и рассчитывать его автоматически. Чтобы закрепить знания на практике, рассмотрим еще один пример.
Как размер массива меняется на практике
Изменение формы массива помогает подготовить исходные данные — после такой обработки их будет удобнее анализировать и преобразовывать.
Представим сервис платформы продаж, который логирует данные по сетевым магазинам в конце рабочего дня в определенном порядке. Аналитики выгрузили данные из закрытого контура платформы. Так они получили 24 значения недельных продаж сети:
orders = [7, 1, 7, 8, 4, 2, 4, 5, 3, 5, 2, 3, 8, 12, 8, 7, 15, 11, 13, 9, 21, 18, 17, 21, 25, 16, 25, 17,] shops_number = 4 orders_matrix = np.array(orders) orders_matrix = orders_matrix.reshape(-1, shops_number) print(orders_matrix) # => [[ 7 1 7 8] # [ 4 2 4 5] # [ 3 5 2 3] # [ 8 12 8 7] # [15 11 13 9] # [21 18 17 21] # [25 16 25 17]] print(orders_matrix.shape) # => (7, 4) Полученный массив данных можно визуализировать в виде такой таблицы:
| День | Магазин №1 | Магазин №2 | Магазин №3 | Магазин №4 |
|---|---|---|---|---|
| 0 | 7 | 1 | 7 | 8 |
| 1 | 4 | 2 | 4 | 5 |
| 2 | 3 | 5 | 2 | 3 |
| 3 | 8 | 12 | 8 | 7 |
| 4 | 15 | 11 | 13 | 9 |
| 5 | 21 | 18 | 17 | 21 |
| 6 | 25 | 16 | 25 | 17 |
Выводы
Метод shape — важный атрибут для структурного описания массива numpy.ndarray . Он помогает узнать размер вдоль каждой оси.
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях: