Переформатирование и слияние — 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. Все методы работают для данных с разной размерностью: одномерными, двумерными и многомерными. При этом на вход методы могут получать любое количество массивов.

Чтобы выбрать правильный метод объединения, проговорите про себя, что нужно сделать:

• Если горизонтально состыковать массивы, используем hstack()
• Если вертикально состыковать массивы, используем vstack()
• Если объединить значений поэлементно из нескольких колонок, используем column_stack()

Самостоятельная работа

word_array = ['мыла', 'мама', 'мама', 'раму', 'мыла', 'мама']

   мама = (0,2,1)
   мыла = (1,3,0)
   раму = (1,1,2)
   мама мыла раму =['мама','мыла','раму'] = [0,2,1,1,3,0,1,1,2]

    def test(code_array: np.array):
        expected_code_array = np.array([1, 3, 0, 0, 2, 1, 0, 2, 1, 1, 1, 2, 1, 3, 0, 0, 2, 1])
        # shape
        assert code_array.shape == expected_code_array.shape
        # type
        assert np.array_equal(code_array, expected_code_array)

    def word2vec(word_array):
        code_rules = {
            'мама' : (0,2,1),
            'мыла' : (1,3,0),
            'раму' : (1,1,2)
        }
        return np.hstack([np.array(code_rules[one_word]) for one_word in word_array])

    code_array = word2vec(word_array)
    test(code_array)

   мама = (0,2,1)
   мыла = (1,3,0)
   раму = (1,1,2)
   мама мыла раму = ['мама', 'мыла', 'раму'] = [[0,2,1],[1,3,0],[1,1,2]]

    def test(code_array: np.array):
        expected_code_array = np.array([
            [1, 3, 0],
            [0, 2, 1],
            [0, 2, 1],
            [1, 1, 2],
            [1, 3, 0],
            [0, 2, 1]]
        )
        # shape
        assert code_array.shape == expected_code_array.shape
        # type
        assert np.array_equal(code_array, expected_code_array)

    def word2matrix(word_array):
        code_rules = {
            'мама' : (0,2,1),
            'мыла' : (1,3,0),
            'раму' : (1,1,2)
        }
        return np.vstack([np.array(code_rules[one_word]) for one_word in word_array])
    code_array = word2matrix(word_array)
    test(code_array)

---

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Об обучении на Хекслете

• Статья «Как учиться и справляться с негативными мыслями»
• Статья «Ловушки обучения»
• Статья «Сложные простые задачи по программированию»
• Вебинар «Как самостоятельно учиться»