Как объединить массивы в Python (с примерами)
Самый простой способ объединить массивы в Python — использовать функцию numpy.concatenate , которая использует следующий синтаксис:
numpy.concatenate ((a1, a2, ….), ось = 0)
- a1, a2…: последовательность массивов
- ось: ось, вдоль которой будут соединяться массивы. По умолчанию 0.
В этом руководстве представлено несколько примеров использования этой функции на практике.
Пример 1: объединение двух массивов
В следующем коде показано, как объединить два одномерных массива:
import numpy as np #create two arrays arr1 = np.array([1, 2, 3, 4, 5]) arr2 = np.array([6, 7, 8]) #concatentate the two arrays np.concatenate ((arr1, arr2)) [1, 2, 3, 4, 5, 6, 7, 8] В следующем коде показано, как объединить два двумерных массива:
import numpy as np #create two arrays arr1 = np.array([[3, 5], [9, 9], [12, 15]]) arr2 = np.array([[4, 0]]) #concatentate the two arrays np.concatenate ((arr1, arr2), axis= 0 ) array([[3, 5], [9, 9], [12, 15], [4, 0]]) #concatentate the two arrays and flatten the result np.concatenate ((arr1, arr2), axis= None ) array([3, 5, 9, 9, 12, 15, 4, 0]) Пример 2. Объединение более двух массивов
Мы можем использовать аналогичный код для объединения более двух массивов:
import numpy as np #create four arrays arr1 = np.array([[3, 5], [9, 9], [12, 15]]) arr2 = np.array([[4, 0]]) arr3 = np.array([[1, 1]]) arr4 = np.array([[8, 8]]) #concatentate all the arrays np.concatenate ((arr1, arr2, arr3, arr4), axis= 0 ) array([[3, 5], [9, 9], [12, 15], [4, 0], [1, 1], [8, 8]]) #concatentate all the arrays and flatten the result np.concatenate ((arr1, arr2, arr3, arr4), axis= None ) array([3, 5, 9, 9, 12, 15, 4, 0, 1, 1, 8, 8]) Дополнительные ресурсы
В следующих руководствах объясняется, как выполнять аналогичные операции в NumPy:
Объединение и разделение массивов
На предыдущем занятии мы познакомились со способами изменения форм массивов. Здесь мы узнаем как реализуются операции объединения и разделения массивов. Для этой задачи в 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-массивы
Объединение данных в единую структуру — это операция, с которой сталкиваются при поступлении данных. С помощью нее мы можем объединять данные из разных источников, а также асинхронные ответы сервера и результаты параллельных и последовательных вычислений. В стандартном Python есть структуры данных list и set . Их можно объединять с помощью append() и update() . Еще можно использовать функцию zip() — она нужна для попарного объединения значений. В Numpy это работает по-другому.
Массивы numpy.ndarray поддерживают сценарии объединения массивов различной размерности по разным осям индексов. Для этого используются четыре метода:
- Конкатенация — concatenate()
- Объединение массивов по горизонтали — hstack()
- Объединение массивов по вертикали — vstack()
- Попарное объединение элементов списков — column_stack()
В этом уроке мы рассмотрим правила их применения и узнаем, какие нюансы нужно учитывать в работе с ними.
Одномерные структуры данных
Начнем с одномерных структур данных, потому что они встречаются чаще всего.
Объединение списков значений в Python делаются операцией + . В Numpy ту же роль выполняют методы concatenate() и hstack() :
import numpy as np arr1 = np.array([0, 1, 2, 3,]) arr2 = np.array([4, 5, 6, 7]) print(np.concatenate([arr1, arr2])) # => [0 1 2 3 4 5 6 7] print(np.hstack([arr1, arr2])) # => [0 1 2 3 4 5 6 7] print([0, 1, 2, 3,] + [4, 5, 6, 7]) # => [0, 1, 2, 3, 4, 5, 6, 7] Обратите внимание, что в примере выше мы объединили массивы по горизонтали. Для этого мы использовали метод hstack() (сокращение от английского horisontal stack).
А теперь попробуем объединить массивы в вертикальном направлении. Здесь понадобится метод vstack() (от англ. vertical stack). Для вертикального объединения также подойдет инициализация нового массива из списка исходных массивов. Этот подход аналогичен формированию списка списков:
print(np.vstack([arr1, arr2])) # => [[0 1 2 3] # [4 5 6 7]] print(np.array([arr1, arr2])) # => [[0 1 2 3] # [4 5 6 7]] print([[0, 1, 2, 3,], [4, 5, 6, 7]]) # => [[0, 1, 2, 3], [4, 5, 6, 7]] Еще одна удобная и распространенная операция — попарное объединение элементов списков. Как уже говорили, в стандартном Python для этой цели используется метод zip() .
В Numpy используется аналог — метод column_stack() :
print(list(zip([0, 1, 2, 3,], [4, 5, 6, 7]))) # => [(0, 4), (1, 5), (2, 6), (3, 7)] print(np.column_stack([arr1, arr2])) # => [[0 4] # [1 5] # [2 6] # [3 7]] В итоге мы рассмотрели все четыре метода и выяснили, как они работают для одномерных массивов. Эти же знания применимы и к массивам с большей размерностью.
Двумерные структуры данных
Попробуем объединить двумерные структуры — матрицы. Это можно сделать в двух направлениях.
В этом примере мы объединим данные по вертикали:
arr1 = np.array([[5, 8], [8, 9]]) arr2 = np.array([[3, 1], [7, 2]]) print(np.concatenate([arr1, arr2])) # => [[5 8] # [8 9] # [3 1] # [7 2]] print(np.vstack([arr1, arr2])) # => [[5 8] # [8 9] # [3 1] # [7 2]] Также можно объединять данные по горизонтали:
print(np.concatenate([arr1, arr2], axis = 1)) # => [[5 8 3 1] # [8 9 7 2]] print(np.hstack((arr1, arr2))) # => [[5 8 3 1] # [8 9 7 2]] Все примеры выше демонстрировали объединение двух массивов. Однако массивов может быть больше.
Многомерные структуры данных
Предположим, что в результате асинхронных запросов к серверу было получено три списка значений для трех дней продаж магазина. Чтобы объединить ответы сервера в единую таблицу, можно использовать все те же методы:
response_values_day1 = np.array([7, 1, 7, 8]) response_values_day2 = np.array([4, 2, 4, 5]) response_values_day3 = np.array([3, 5, 2, 3]) orders = np.vstack([ response_values_day1, response_values_day2, response_values_day3, ]) print(orders) # => [[7 1 7 8] # [4 2 4 5] # [3 5 2 3]] Запросы к серверу могут быть не по дням, а по магазинам. В этом случае также применимы методы объединения:
response_values_shop1 = np.array([ 7, 4, 3,]) response_values_shop2 = np.array([ 1, 2, 5,]) response_values_shop3 = np.array([ 7, 4, 2,]) response_values_shop4 = np.array([ 8, 5, 3,]) orders = np.vstack([ response_values_shop1, response_values_shop2, response_values_shop3, response_values_shop4, ]) print(orders.T) # => [[7 1 7 8] # [4 2 4 5] # [3 5 2 3]] В примере выше используется транспонирование матрицы. Результат транспонирования — это матрица, в которой столбцы исходной таблицы становятся строками.
Посмотрим на исходную матрицу:
print(orders) # => [[7 4 3] # [1 2 5] # [7 4 2] # [8 5 3]] А теперь сравним ее с транспонированной:
print(orders.T) # => [[7 1 7 8] # [4 2 4 5] # [3 5 2 3]] Выводы
В этом уроке мы рассмотрели методы объединения массивов numpy.ndarray . Все методы работают для данных с разной размерностью: одномерными, двумерными и многомерными. При этом на вход методы могут получать любое количество массивов.
Чтобы выбрать правильный метод объединения, проговорите про себя, что нужно сделать:
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
Как сложить элементы двух списков?
Если важно сохранить начальные списки, то попробуем по другому:
# заполнение переменных a = [1, 2, 3, 4] b = [1, 2, 3] # обработка c = map(sum, zip(a + [0,]*(len(b)-len(a)), b + [0,]*(len(a)-len(b)))) # вывод результата print(list(c)) Вариант 3:
В Python 3.8 появился «морж» — оператор := Если важно не повторить функционал:
# заполнение переменных a = [1, 2, 3, 4] b = [1, 2, 3] # обработка c = map(sum, zip(a + [0, ] * (x := len(b) - len(a)), b + [0, ] * -x)) # вывод результата print(list(c)) Результат: > [2, 4, 6, 4] Отслеживать
ответ дан 19 мар 2021 в 13:02
121 6 6 бронзовых знаков
Вариант забавный, но 1) он меняет исходные списки, 2) повторяет функционал itertools.zip_longest
19 мар 2021 в 13:10
Так то пусть будет, разные ответы это хорошо )
19 мар 2021 в 13:19
согласен, не без недостатков, но как вариант для «по быстрому»
19 мар 2021 в 13:20
добавил варианты без изменения исходных списков и вариант для Python 3.8 без повтора функционала
19 мар 2021 в 13:54
Если вы еще не «прошли ‘from’ ‘import'», то наиболее простой вариант выглядит вот так:
с=list(map(lambda x, y: x + y, a, b)) c1 = [x+y for x,y in zip(a,b)] + (a if len(a) >= len(b) else b)[min(len(a), len(b)):] При необходимости обернуть это в вызов функции, надеюсь, сможете сделать самостоятельно: на вход a и b, указанные выражения — в качестве параметра в return.
Отслеживать
ответ дан 22 дек 2019 в 14:14
11.6k 2 2 золотых знака 10 10 серебряных знаков 16 16 бронзовых знаков
Спасибо тебе за ответ) мне нужно просто без комприхенш`на может просто через def и внутри def через for буду рад если поможете = )
23 дек 2019 в 8:51
Если у вас списка ВСЕГДА точно будут одной длины, то можно воспользоваться генератор списков и zip:
a = [1, 2, 3] b = [4, 5, 6] c = [x+y for x, y in zip(a, b)] print(c) #[5, 7, 9] Но если вы НЕ уверены, что длина списков будет одинаковой хоть раз, то здесь нужно воспользоваться крутой библиотекой itertools:
from itertools import zip_longest a = [1, 2, 3] b = [4, 5, 6, 10] c = [x+y for x, y in zip_longest(a, b, fillvalue=0) #fillvalue нужен, если ваши списки разных рамеров и там где не достаёт элементов, добьёт нулями. print(c) #[5, 7, 9, 10] Ответ на комментарий:
from itertools import zip_longest def add_list(a, b): c = [x+y for x, y in zip_longest(a, b, fillvalue=0)] return c a = [1, 2, 3] b = [4, 5, 6, 10] summ_list = add_list(a, b) print(summ_list)