Numpy как добавить элемент в массив

NumPy, часть 2: базовые операции над массивами

Здравствуйте! Я продолжаю работу над пособием по python-библиотеке NumPy.

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

Сегодня мы познакомимся с операциями над массивами.

Базовые операции

Математические операции над массивами выполняются поэлементно. Создается новый массив, который заполняется результатами действия оператора.

       :1: RuntimeWarning: divide by zero encountered in true_divide    

Для этого, естественно, массивы должны быть одинаковых размеров.

  File 

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

NumPy также предоставляет множество математических операций для обработки массивов:

Полный список можно посмотреть здесь.

Многие унарные операции, такие как, например, вычисление суммы всех элементов массива, представлены также и в виде методов класса ndarray.

 
Индексы, срезы, итерации
Одномерные массивы осуществляют операции индексирования, срезов и итераций очень схожим образом с обычными списками и другими последовательностями Python (разве что удалять с помощью срезов нельзя).
           File  У многомерных массивов на каждую ось приходится один индекс. Индексы передаются в виде последовательности чисел, разделенных запятыми (то бишь, кортежами):
Когда индексов меньше, чем осей, отсутствующие индексы предполагаются дополненными с помощью срезов:
b[i] можно читать как b[i, ]. В NumPy это также может быть записано с помощью точек, как b[i, . ].
Например, если x имеет ранг 5 (то есть у него 5 осей), тогда

x[1, 2, . ] эквивалентно x[1, 2, :, :, :],
x[. , 3] то же самое, что x[:, :, :, :, 3] и
x[4, . , 5, :] это x[4, :, :, 5, :].

Итерирование многомерных массивов начинается с первой оси:
Однако, если нужно перебрать поэлементно весь массив, как если бы он был одномерным, для этого можно использовать атрибут flat:
Как уже говорилось, у массива есть форма (shape), определяемая числом элементов вдоль каждой оси:
Форма массива может быть изменена с помощью различных команд:






Порядок элементов в массиве в результате функции ravel() соответствует обычному "C-стилю", то есть, чем правее индекс, тем он "быстрее изменяется": за элементом a[0,0] следует a[0,1]. Если одна форма массива была изменена на другую, массив переформировывается также в "C-стиле". Функции ravel() и reshape() также могут работать (при использовании дополнительного аргумента) в FORTRAN-стиле, в котором быстрее изменяется более левый индекс.
Метод reshape() возвращает ее аргумент с измененной формой, в то время как метод resize() изменяет сам массив:
Если при операции такой перестройки один из аргументов задается как -1, то он автоматически рассчитывается в соответствии с остальными заданными:
Объединение массивов
Несколько массивов могут быть объединены вместе вдоль разных осей с помощью функций hstack и vstack.
hstack() объединяет массивы по первым осям, vstack() — по последним:
Функция column_stack() объединяет одномерные массивы в качестве столбцов двумерного массива:
Аналогично для строк имеется функция row_stack().
Разбиение массива
Используя hsplit() вы можете разбить массив вдоль горизонтальной оси, указав либо число возвращаемых массивов одинаковой формы, либо номера столбцов, после которых массив разрезается "ножницами":






Функция vsplit() разбивает массив вдоль вертикальной оси, а array_split() позволяет указать оси, вдоль которых произойдет разбиение.
Копии и представления
При работе с массивами, их данные иногда необходимо копировать в другой массив, а иногда нет. Это часто является источником путаницы. Возможно 3 случая:
Вообще никаких копий
Простое присваивание не создает ни копии массива, ни копии его данных:
Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий.
Представление или поверхностная копия
Разные объекты массивов могут использовать одни и те же данные. Метод view() создает новый объект массива, являющийся представлением тех же данных.
Срез массива это представление:
Глубокая копия
Метод copy() создаст настоящую копию массива и его данных:
Для вставки кода на Python в комментарий заключайте его в теги 









Модуль csv - чтение и запись CSV файлов
Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
Онлайн-обучение Python: сравнение популярных программ


Книги о Python
GUI (графический интерфейс пользователя)
Курсы Python
Модули
Новости мира Python
NumPy
Обработка данных
Основы программирования
Примеры программ
Типы данных в Python
Видео
Python для Web
Работа для Python-программистов


Сделай свой вклад в развитие сайта!
Самоучитель Python
Карта сайта
Отзывы на книги по Python
Реклама на сайте

Изменение формы массивов, добавление и удаление осей
На предыдущем занятии мы немного познакомились со способами изменения формы массивов пакета NumPy, то есть изменением их размерностей. На этом занятии поближе рассмотрим эту тему и познакомимся с наиболее употребительными функциями и свойствами, влияющих на представление массивов.
Изменение размерности массивов
Предположим, у нас имеется массив, состоящий из десяти чисел:
a = np.arange(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Мы уже знаем, что для изменения формы этого массива, достаточно указать свойству shape кортеж с новыми размерами, например, так:
a.shape = 2, 5 # массив размерностью 2x5
В результате изменится представление массива, на которое ссылается переменная a. Если же требуется создать новое представление массива, сохранив прежнее, то следует воспользоваться методом reshape():
b = a.reshape(10) # массив [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
И, как мы с вами говорили на предыдущем занятии, ссылки b и a будут использовать одни и те же данные, то есть, изменение массива через b:
b[0] = -1
приведет к изменению соответствующего элемента массива a:
array([[-1, 1, 2, 3, 4], 
[ 5, 6, 7, 8, 9]])
Об этом всегда следует помнить. Также следует помнить, что у свойства shape и метода reshape() размерность должна охватывать все элементы массива. Например, вот такая команда:






a.shape = 3, 3
приведет к ошибке, т.к. размерность 3x3 = 9 элементов, а в массиве 10 элементов. Здесь всегда должно выполняться равенство:
n1 x n2 x … x nN = число элементов массива
Но допускается делать так:
a.shape = -1, 2 # размерность 5x2
Отрицательное значение -1 означает автоматическое вычисление размерности по первой оси. По второй берется значение 2. В этом случае получим размерность 5x2.
То же самое можно делать и в методе reshape():
b.reshape(-1, 1) # размерность 10x1 b.reshape(1, -1) # размерность 1x10
Обратите внимание, в последних двух случаях мы получаем представления двумерных массивов, преобразуя одномерный. Это важный момент, так как на выходе метода reshape() получается матрица с двумя осями (строки и столбцы), тогда как изначально массив b имел только одну ось. Не случайно последнее представление отображается с двумя квадратными скобками:
array([[-1, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
Первая скобка – это первая ось (строка), а вторая скобка (вторая ось) описывает столбцы. Одномерный же массив b отображается с одной квадратной скобкой:






array([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Используя отрицательный индекс, можно делать и такие преобразования:
b.reshape(2, -1) # размерность 2x5 b.reshape(-1, 2) # размерность 5x2
Первое представление (2x5) отображается следующим образом:
array([[-1, 1, 2, 3, 4], 
[ 5, 6, 7, 8, 9]])
Здесь снова мы видим две квадратные скобки (значит, массив двумерный). Первая описывает ось axis0, отвечающую за строки, а вложенные скобки описывают вторую ось axis1, отвечающую за столбцы.
Если нам требуется многомерный массив преобразовать в обычный одномерный, то можно воспользоваться методом ravel(), который возвращает новое представление, не меняя текущего:
c = b.ravel() # с ссылается на одномерное представление массива
Если же нам нужно текущий массив преобразовать в одномерный, то это можно сделать так:
b.shape = -1
Помимо свойства shape можно использовать метод resize, который выполняет подобную операцию с текущим массивом. Например:
a.resize(2, 5) # массив 2x5
Но, как мы уже говорили, вот такая строчка приведет к ошибке:






a.resize(3, 3) # ошибка: 3x3 != 10
Однако, мы все-таки можем выполнить такую операцию, указав дополнительно флаг refcheck=False:
a.resize(3, 3, refcheck=False) # массив 3x3
a.resize(4, 5, refcheck=False) # массив 4x5
В первом случае происходит удаление одного 10-го элемента, а во втором случае – добавление 4∙5 - 3∙3 = 11 нулей. Это очень удобно, когда нам нужно менять не только форму, но и размер самого массива.
Транспонирование матриц и векторов
Очень часто в математических операциях требуется выполнять транспонирование матриц и векторов, то есть, заменять строки на столбцы. Например, если имеется матрица (двумерный массив):
a = np.array([(1, 2, 3), (1, 4, 9), (1, 8, 27)])
то операция транспонирования может быть реализована так:
b = a.T
Обратите внимание, мы здесь создаем лишь новое представление тех же самых данных массива a. И изменение элементов в массиве b:
b[0, 1] = 10
приведет к соответствующему изменению значения элемента и массива a. Это следует помнить, используя операцию транспонирования.
Транспонирование векторов работает несколько иначе. Предположим, имеется одномерный массив:
x = np.arange(1, 10)
и мы выполняем операцию транспонирования:






В результате ничего не изменилось: вектор как был строкой, так строкой и остался. Почему? Дело в том, что массив x имеет только одну размерность, поэтому здесь нет понятия строк и столбцов. Соответственно, операция транспонирования ни к чему не приводит. Чтобы получить ожидаемый эффект, нужно добавить к массиву еще одну ось, например, так:
x.shape = 1, -1
И теперь, при транспонировании получим вектор-столбец:
x.T # вектор-столбец 9x1
Добавление и удаление осей

np.expand_dims(a, axis) – добавление новой оси;
np.squeeze(a[, axis]) – удаление оси (без удаления элементов).

x_test = np.arange(32).reshape(8, 2, 2) # массив 8x2x2
И нам потребовалось добавить еще одно измерение (ось), причем, в самое начало, то есть, ось axis0. Сейчас на этой оси 8 элементов – матриц 2x2, но мы хотим сделать четырехмерный массив, сохранив остальные три оси и их данные без изменений. Как раз это достаточно просто сделать с помощью функции expand_dims, следующим образом:
x_test4 = np.expand_dims(x_test, axis=0)
Обращаясь к свойству shape:
x_test4.shape # (1, 8, 2, 2)
Видим, что массив стал четырехмерным и первая добавленная ось axis0 содержит один элемент – трехмерный массив 8x2x2. При необходимости, мы всегда можем добавить новый элемент на эту ось:
a = np.append(x_test4, x_test4, axis=0) # размерность (2, 8, 2, 2)
или удалить ненужные элементы:
b = np.delete(a, 0, axis=0) # размерность (1, 8, 2, 2)
Здесь второй параметр 0 – индекс удаляемого элемента на оси axis0. Если нам нужно добавить последнюю ось в массиве, то для этого можно записать такую команду:
b = np.expand_dims(x_test4, axis=-1) # размерность (1, 8, 2, 2, 1)
Отрицательный индекс -1 – это следующая с конца ось. Если указать индекс -2, то добавится предпоследняя ось и так далее. Отрицательные индексы очень удобно использовать при работе с массивами произвольных размерностей. Следующая функция squeeze позволяет удалить все оси с одним элементом. Например, строчка:
c = np.squeeze(b) # размерность (8, 2, 2)
превращает массив размерностью (1, 8, 2, 2) в массив размерностью (8, 2, 2). При необходимости, дополнительно мы можем самостоятельно указать оси, которые следует удалять, например, так:






c = np.squeeze(b, axis=0) # удалит только ось axis0, не затронув другие
Но, если указать ось с числом элементов больше 1, то возникнет ошибка:
c = np.squeeze(b, axis=1) # ошибка, на оси axis1 8 элементов
Объект newaxis
В NumPy добавлять новые оси иногда удобнее с помощью специального объекта np.newaxis. Например, пусть у нас есть одномерный массив:
a = np.arange(1, 10) # array([1, 2, 3, 4, 5, 6, 7, 8, 9])
У него одна ось – одно измерение. Добавим еще одну ось, допустим, в начало. С помощью объекта np.newaxis это можно сделать так:
b = a[np.newaxis, :] # добавление оси axis0 b.shape # (1, 9)
Или, можно прописать сразу две оси:
c = a[np.newaxis, :, np.newaxis] c.shape # (1, 9, 1)
Как видите, это достаточно удобная операция.
Видео по теме























© 2024 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Многомерные массивы в Numpy — Python: Numpy-массивы
Библиотека Numpy дает мощный и удобный высокоуровневый аппарат для работы с многомерными данными. Для работы с ними в Numpy разработана своя собственная структура данных — массив numpy.ndarray . Именно под эту структуру оптимизирована работа всего функционала библиотеки.
В этом уроке познакомимся с тем, как создавать массив ndarray из стандартных типов данных языка Python и попробуем на практике решить ряд простых аналитических задач.
Структура данных библиотеки Numpy
Чтобы создать структуру numpy.ndarray , нужно конвертировать список list . Для конвертации из множества set требуется дополнительное приведение типа данных.
Рассмотрим на таком примере:
# Импортируем библиотеку numpy с псевдонимом np import numpy as np # Создаем простой пример списка языка Python simple_list = [1, 2, 3, 4, 5] # Конвертируем созданный список в массив Numpy my_first_ndarray = np.array(simple_list, dtype=int) # Тип созданного объекта print(type(my_first_ndarray)) # => # Результат стандартного вывода print(my_first_ndarray) # => [1 2 3 4 5] 
А теперь разберем этот код подробнее. Сам пример показывает встроенную функциональность для создания структуры numpy.ndarray . Мы импортируем библиотеку Numpy, создаем короткий список значений simple_list , а затем конвертируем в массив my_first_ndarray . Для этого вызываем конструктор np.array() с объектами для конвертации.
С учетом примера выше, обратная конвертация в список происходит так:






print(ndarray_from_list.tolist()) 
Конвертация из списка Python — это самая популярная операция, с помощью которой создается структура numpy.ndarray .
Так происходит потому, что обмен данными между функциями и сервисами удобно производить в стандартных структурах данных языка. Другими словами, можно не вводить структуры данных сторонних библиотек и не усложнять программу.
Но при разработке сложных программ модуль numpy.ndarray может быть только частью общей структуры. В таких случаях используют стандартные типы данных языка для обмена данными между функциональными частями программ.
В итоге порядок работы с данными при работе с Numpy выглядит следующим образом:
Как правило, вычислительные и аналитические модули в виде входных данных ожидают списки значений. Всю оптимизацию они делают уже внутри себя в собственных абстракциях, невидимых извне. Это сделано для простоты интеграции.
Допустимые типы данных
Поговорим подробнее о типах элементов массива, которые можно использовать для numpy.ndarray . Продолжим работать с тем же примером и воспользуемся следующим методом:
# Проверяем тип полученного массива print(my_first_ndarray.dtype.type) # => 
Как и ожидалось, тип данных — int64. Необязательно ограничиваться только им:
# Целочисленный массив print(np.array([1, 2, 3], dtype=int).dtype.type) # => # Массив строк print(np.array([1, 2, 3], dtype=str).dtype.type) # => # Массив чисел с плавающей запятой print(np.array([1, 2, 3], dtype=float).dtype.type) # => 
Обратите внимание, что для экземпляра структуры numpy.ndarray нельзя использовать сразу несколько типов данных. Проще говоря, все элементы в массиве должны быть однотипные. Посмотрим, как конструктор сам определит тип данных при конвертации:






# Все элементы списка целочисленные print(np.array([1, 2, 3]).dtype.type) # => # Все элементы списка — это строки print(np.array(['1', '2', '3']).dtype.type) # => # Элементы списка как текстовые, так и целочисленные print(np.array(['1', 2, 3]).dtype.type) # => 
Заметим, что ошибки при конвертации смешанного типа элементов массива не произошло. Конвертор просто привел все данные к строковому типу.
Как Numpy работает на практике
Функциональность библиотеки Numpy настолько интуитивна, что уже сейчас можно решить простую аналитическую задачку.
Представим продажи ноутбуков в магазине за одну неделю:


День
Магазин №1



0
7


1
4


2
3


3
8


4
15


5
21


6
25


На практике такие данные обычно хранятся в табличном виде в базе данных. Чтобы упростить пример, мы пропустили этап выгрузки — подразумевается, что данные приходят в вычислительный модуль уже в виде списка значений.
Поработаем с данными с помощью библиотеки Numpy:
# Импортируем библиотеку numpy с псевдонимом np import numpy as np # Создаем список продаж — представим, что считали его из базы данных orders_list = [7, 4, 3, 8, 15, 21, 25] # Конвертируем созданный список в массив Numpy orders_ndarray = np.array(orders_list, dtype=int) # Тип созданного объекта print(type(orders_ndarray)) # => # Результат стандартного вывода print(orders_ndarray) # => [ 7 4 3 8 15 21 25] 
Попробуем найти день недели с самыми низкими продажами. Опыт работы с Python подсказывает, что метод будет называться min() или minimum() . Найдем минимальное количество продаж и заодно день недели, в который оно совершено:
# Находим минимальный элемент массива print(orders_ndarray.min()) # => 3 # Находим порядковый номер минимального элемента массива print(orders_ndarray.argmin()) # => 2 
Чтобы найти наибольшее количество продаж, достаточно поменять одну функцию:
# Находим максимальный элемент массива print(orders_ndarray.max()) # => 25 
На практике часто анализ не ограничивается только одной неделей продаж и одним магазином. В этом случае набор данных представлен в виде списка списков элементов — это уже двумерная структура, которая в математике называется матрицей.
В Numpy реализация инициализации массивов и функций работы с ними не зависит от размерности данных, что существенно упрощает разработку.






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


День
Магазин №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


Мы ожидаем, что функционально все должно быть реализовано похожим образом. Давайте в этом убедимся, взглянув на код:
# Импортируем библиотеку numpy с псевдонимом np import numpy as np # Создаем «список списков продаж» orders_list = [ [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] ] # Конвертируем созданный «список списков» в массив Numpy orders_ndarray = np.array(orders_list, dtype=int) # Описываем тип созданного объекта print(type(orders_ndarray)) # => # Находим минимальный элемент массива print(orders_ndarray.min()) # => 1 
В приведенном примере метод min() находит минимальный элемент среди всех значений массива.
Большинство функций в Numpy реализованы так, что методы и функции выполняют одинаковые операции, вне зависимости от типа данных на входе.
В программировании такой подход называется полиморфизмом. Он упрощает разработку и делает код более простым для анализа и поддержки.
Выводы
Сегодня мы познакомились с основной структурой данных библиотеки Numpy — массивом numpy.ndarray .
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

130 курсов, 2000+ часов теории
1000 практических заданий в браузере
360 000 студентов

Наши выпускники работают в компаниях:






Добавление элементов в массив в Python 
В Python нет встроенного типа данных “массив”, но есть модули, которые позволяют работать с массивами. В этой статье мы рассмотрим, как добавлять данные в массив с помощью модулей array и NumPy. Модуль array полезен, когда нужно создать массив целых чисел и чисел с плавающей точкой. А модуль NumPy пригодится, когда вам нужно выполнить математические операции с массивом.
Во многих случаях создать массив вы можете с помощью List, поскольку он обеспечивает гибкость (например смешанные типы данных) и по-прежнему обладает всеми характеристиками массива.
Примечание: в массив можно добавлять только элементы одного типа данных. Соответственно, объединять можно только два массива с одинаковым типом данных.
Добавление элементов в массив
С помощью модуля array можно объединять массивы при помощи оператора + и добавлять элементы в массив методами append(), extend() и insert().

Оператор +, x + y: возвращает новый массив с элементами из двух массивов.
append(x): добавляет один элемент в конец массива.
extend(iterable): добавляет список, массив или другую итерабельную переменную в конец массива.
insert(i, x): вставляет элемент перед заданным индексом массива.

В следующем примере показано, как создать новый объект массива путем объединения двух других массивов:
import array # create array objects, of type integer arr1 = array.array('i', [1, 2, 3]) arr2 = array.array('i', [4, 5, 6]) # print the arrays print("arr1 is:", arr1) print("arr2 is:", arr2) # create a new array that contains all of the elements of both arrays # and print the result arr3 = arr1 + arr2 print("After arr3 = arr1 + arr2, arr3 is:", arr3)
Получим следующий вывод:
arr1 is: array('i', [1, 2, 3]) arr2 is: array('i', [4, 5, 6]) After arr3 = arr1 + arr2, arr3 is: array('i', [1, 2, 3, 4, 5, 6])
В предыдущем примере создается новый массив, в котором содержатся все элементы заданных массивов.
А в следующем примере показано, как добавлять данные в массив с помощью методов append(), extend() и insert():






import array # create array objects, of type integer arr1 = array.array('i', [1, 2, 3]) arr2 = array.array('i', [4, 5, 6]) # print the arrays print("arr1 is:", arr1) print("arr2 is:", arr2) # append an integer to an array and print the result arr1.append(4) print("\nAfter arr1.append(4), arr1 is:", arr1) # extend an array by appending another array of the same type # and print the result arr1.extend(arr2) print("\nAfter arr1.extend(arr2), arr1 is:", arr1) # insert an integer before index position 0 and print the result arr1.insert(0, 10) print("\nAfter arr1.insert(0, 10), arr1 is:", arr1)
Получаем следующий вывод:
arr1 is: array('i', [1, 2, 3]) arr2 is: array('i', [4, 5, 6]) After arr1.append(4), arr1 is: array('i', [1, 2, 3, 4]) After arr1.extend(arr2), arr1 is: array('i', [1, 2, 3, 4, 4, 5, 6]) After arr1.insert(0, 10), arr1 is: array('i', [10, 1, 2, 3, 4, 4, 5, 6])
В предыдущем примере каждый метод вызывается на объекте массива arr1 и изменяет исходный объект.
Добавление элементов в массив NumPy
С модулем NumPy вы можете использовать функции NumPy append() и insert() для добавления элементов в массив.

numpy.append(arr, values, axis=None): добавляет значения или массив в конец копии arr. Если параметр axis не указан, то по умолчанию используется значение None, что означает, что arr и values выравниваются перед операцией append.
numpy.insert(arr, obj, values, axis=None): вставляет значения или массив перед индексом (obj) вдоль оси. Если параметр axis не указан, то по умолчанию используется значение None, что означает, что перед операцией insert выравнивается только arr.

numpy.append() использует функцию numpy.concatenate() в фоновом режиме. Метод numpy.concatenate() объединяет последовательность массивов вдоль указанной оси. Узнать больше о работе с массивами вы можете в документации NumPy.
Примечание: для тестирования примеров кода в этом разделе необходимо установить NumPy .
Примеры на этом этапе используют двумерные (2D) массивы, чтобы показать, как функции обрабатывают массивы в зависимости от значения axis.
Добавление в массив с помощью numpy.append()
Массивы NumPy можно описать по размеру и форме. При добавлении значений или массивов в многомерные массивы добавляемый массив или значения должны иметь одинаковую форму, за исключением указанной оси.
Чтобы понять форму 2D массива, рассмотрим строки и столбцы. array([[1, 2], [3, 4]]) имеет форму 2, 2, эквивалентную 2 строкам и 2 столбцам; array([[10, 20, 30], [40, 50, 60]] ) имеет форму 2, 3, эквивалентную 2 строкам и 3 столбцам.
Протестируйте эту концепцию с помощью интерактивной консоли Python.
Сначала импортируйте модуль NumPy, затем создайте несколько массивов и проверьте их форму.
Импортируйте NumPy, затем создайте и выведите np_arr1:
import numpy as np np_arr1 = np.array([[1, 2], [3, 4]]) print(np_arr1)
Получим следующий вывод:
[[1 2] [3 4]]
Проверьте форму np_arr1:
np_arr1.shape (2, 2)
Создайте и выведите ещё один массив, np_arr2:
np_arr2 = np.array([[10, 20, 30], [40, 50, 60]]) print(np_arr2) [[10 20 30] [40 50 60]]
Проверьте форму np_arr2:
np_arr2.shape (2, 3)
Затем попробуйте добавить массивы по разным осям. Вы можете добавить массив формы 2, 3 к массиву формы 2, 2 вдоль оси 1, но не вдоль оси 0.
Добавьте np_arr2 к np_arr1 вдоль axis 0 или по строкам:
np.append(np_arr1, np_arr2, axis=0)
Вы получите ошибку ValueError:
Traceback (most recent call last): File "", line 1, in File "", line 5, in append File "/Users/digitalocean/opt/anaconda3/lib/python3.9/site-packages/numpy/lib/function_base.py", line 4817, in append return concatenate((arr, values), axis=axis) File "", line 5, in concatenate ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 2 and the array at index 1 has size 3
Выполнить добавление массива с тремя столбцами в массив с двумя столбцами невозможно.
Вы можете добавить массив np_arr2 к np_arr1 вдоль оси 1, то есть по столбцам:
np.append(np_arr1, np_arr2, axis=1)
Вывод будет следующим:
array([[ 1, 2, 10, 20, 30], [ 3, 4, 40, 50, 60]])
Вы можете добавить массив со столбцами высотой в две строки к другому массиву со столбцами высотой в две строки.
В следующем примере показано, как добавлять элементы в массив NumPy с помощью функции numpy.append():
import numpy as np # create 2D array objects (integers) np_arr1 = np.array([[1, 2], [3, 4]]) np_arr2 = np.array([[10, 20], [30, 40]]) # print the arrays print("np_arr1 is:\n", np_arr1) print("np_arr2 is:\n", np_arr2) # append an array to the end of another array and print the result # both arrays are flattened before appending append_axis_none = np.append(np_arr1, np_arr2, axis=None) print("append_axis_none is:\n", append_axis_none) # append an array to the end of another array along axis 0 (append rows) # and print the result append_axis_0 = np.append(np_arr1, np_arr2, axis=0) print("append_axis_0 is:\n", append_axis_0) # append an array to the end of another array along axis 1 (append columns) # and print the result append_axis_1 = np.append(np_arr1, np_arr2, axis=1) print("append_axis_1 is:\n", append_axis_1)
Получаем следующий вывод:
np_arr1 is: [[1 2] [3 4]] np_arr2 is: [[10 20] [30 40]] append_axis_none is: [ 1 2 3 4 10 20 30 40] append_axis_0 is: [[ 1 2] [ 3 4] [10 20] [30 40]] append_axis_1 is: [[ 1 2 10 20] [ 3 4 30 40]]
Предыдущий пример демонстрирует работу функции numpy.append() для каждой оси 2D-массива и как изменяется форма полученного массива. Если ось равна 0, массив дополняется строками. Если ось равна 1, массив дополняется столбцами.
Добавление элементов в массив с помощью numpy.insert()
Функция numpy.insert() вставляет массив или значения в другой массив перед указанным индексом вдоль оси и возвращает новый массив.
В отличие от функции numpy.append(), если ось не указана или указана как None, то функция numpy.insert() сглаживает только первый массив и не сглаживает значения или массив, которые нужно вставить. Если вы попытаетесь вставить 2D-массив в другой 2D-массив без указания оси, то вы получите ошибку ValueError.
В следующем примере показано, как вставлять элементы в массив с помощью функции numpy.insert():
import numpy as np # create array objects (integers) np_arr1 = np.array([[1, 2], [4, 5]]) np_arr2 = np.array([[10, 20], [30, 40]]) np_arr3 = np.array([100, 200, 300]) # print the arrays print("np_arr1 is:\n", np_arr1) print("np_arr2 is:\n", np_arr2) print("np_arr3 is:\n", np_arr3) # insert a 1D array into a 2D array and then print the result # the original array is flattened before insertion insert_axis_none = np.insert(np_arr1, 1, np_arr3, axis=None) print("insert_axis_none is:\n", insert_axis_none) # insert an array into another array by row # and print the result insert_axis_0 = np.insert(np_arr1, 1, np_arr2, axis=0) print("insert_axis_0 is:\n", insert_axis_0) # insert an array into another array by column # and print the result insert_axis_1 = np.insert(np_arr1, 1, np_arr2, axis=1) print("insert_axis_1 is:\n", insert_axis_1)
Вывод будет следующим:
np_arr1 is: [[1 2] [4 5]] np_arr2 is: [[10 20] [30 40]] insert_axis_none is: [ 1 100 200 300 2 4 5] insert_axis_0 is: [[ 1 2] [10 20] [30 40] [ 4 5]] insert_axis_1 is: [[ 1 10 30 2] [ 4 20 40 5]]
В предыдущем примере, когда вы вставляли 2D-массив в другой 2D-массив вдоль оси 1, каждый массив в np_arr2 был вставлен как отдельный столбец в np_arr1. Если вы хотите вставить целый 2D-массив в другой 2D-массив, добавьте квадратные скобки вокруг значения obj, чтобы указать, что весь массив должен быть вставлен перед этой позицией. Без квадратных скобок numpy.insert() складывает массивы по порядку в виде столбцов перед заданным индексом.
В следующем примере показан вывод с квадратными скобками вокруг значения параметра obj (index) и без них:
import numpy as np # create 2D array objects (integers) np_arr1 = np.array([[1, 2], [3, 4]]) np_arr2 = np.array([[10, 20], [30, 40]]) # print the arrays print("np_arr1 is:\n", np_arr1) print("np_arr2 is:\n", np_arr2) # insert an array, column by column, into another array # and print the result insert_axis_1 = np.insert(np_arr1, 1, np_arr2, axis=1) print("insert_axis_1 is:\n", insert_axis_1) # insert a whole array into another array by column # and print the result insert_index_axis_1 = np.insert(np_arr1, [1], np_arr2, axis=1) print("insert_index_axis_1 is:\n", insert_index_axis_1)
Вы получите следующий вывод:
np_arr1 is: [[1 2] [3 4]] np_arr2 is: [[10 20] [30 40]] insert_axis_1 is: [[ 1 10 30 2] [ 3 20 40 4]] insert_index_axis_1 is: [[ 1 10 20 2] [ 3 30 40 4]]
В предыдущем примере показано, как numpy.insert() вставляет столбцы в массив в зависимости от обозначенного index.
Подводим итоги
В этом мануале мы добавили элементы в массивы с помощью модулей array и NumPy.


Похожие публикации:

Как подключить аирподс к телевизору самсунг
Как сделать руль легче на ваз 2114
Как создать игру в командной строке
Какая клавиатура на айфоне