np hstack python что это

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

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

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

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

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

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

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

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

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

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

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

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

Индексы, срезы, итерации

Одномерные массивы осуществляют операции индексирования, срезов и итераций очень схожим образом с обычными списками и другими последовательностями Python (разве что удалять с помощью срезов нельзя).

У многомерных массивов на каждую ось приходится один индекс. Индексы передаются в виде последовательности чисел, разделенных запятыми (то бишь, кортежами):

Когда индексов меньше, чем осей, отсутствующие индексы предполагаются дополненными с помощью срезов:

Например, если x имеет ранг 5 (то есть у него 5 осей), тогда

Итерирование многомерных массивов начинается с первой оси:

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

Манипуляции с формой

Как уже говорилось, у массива есть форма (shape), определяемая числом элементов вдоль каждой оси:

Форма массива может быть изменена с помощью различных команд:

Порядок элементов в массиве в результате функции ravel() соответствует обычному «C-стилю», то есть, чем правее индекс, тем он «быстрее изменяется»: за элементом a[0,0] следует a[0,1]. Если одна форма массива была изменена на другую, массив переформировывается также в «C-стиле». Функции ravel() и reshape() также могут работать (при использовании дополнительного аргумента) в FORTRAN-стиле, в котором быстрее изменяется более левый индекс.

Метод reshape() возвращает ее аргумент с измененной формой, в то время как метод resize() изменяет сам массив:

Объединение массивов

Несколько массивов могут быть объединены вместе вдоль разных осей с помощью функций hstack и vstack.

hstack() объединяет массивы по первым осям, vstack() — по последним:

Функция column_stack() объединяет одномерные массивы в качестве столбцов двумерного массива:

Аналогично для строк имеется функция row_stack().

Разбиение массива

Используя hsplit() вы можете разбить массив вдоль горизонтальной оси, указав либо число возвращаемых массивов одинаковой формы, либо номера столбцов, после которых массив разрезается «ножницами»:

Функция vsplit() разбивает массив вдоль вертикальной оси, а array_split() позволяет указать оси, вдоль которых произойдет разбиение.

Копии и представления

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

Вообще никаких копий

Простое присваивание не создает ни копии массива, ни копии его данных:

Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий.

Представление или поверхностная копия

Разные объекты массивов могут использовать одни и те же данные. Метод view() создает новый объект массива, являющийся представлением тех же данных.

Срез массива это представление:

Глубокая копия

Метод copy() создаст настоящую копию массива и его данных:

Источник

Объединение и разделение массивов

На предыдущем занятии мы познакомились со способами изменения форм массивов. Здесь мы узнаем как реализуются операции объединения и разделения массивов. Для этой задачи в NumPy реализованы специальные функции, которые мы сейчас и рассмотрим.

Функции hstack и vstack

Предположим у нас есть два двумерных массива:

Их можно объединить как по горизонтали, так и по вертикали, с помощью функций:

Примеры работы этих двух функций представлены на рисунке ниже:

Эти же операции можно выполнять и с многомерными массивами. Например, определим два трехмерных массива:

И выполним функции:

Как видите, здесь произошло формальное объединение по оси axis1 в функции hstack и по оси axis0 в функции vstack.

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

Аналогичным образом происходит объединение и одномерных массивов:

array([1., 2., 3., 4., 5., 6., 7., 8.])

А во втором случае:

результатом будет двумерный массив:

Функции column_stack и row_stack

Давайте теперь зададимся вопросом: как объединить наши два одномерных массива столбцами? Чтобы результат выглядел вот так:

Для этого хорошо подходит функция column_stack():

Если с ее помощью объединять двумерные и многомерные массивы, то она будет давать тот же результат, что и функция hstack().

Другая аналогичная функция row_stack(), в принципе, делает то же самое, что и функция vstack() заметных отличий здесь нет. Ее можно использовать так:

Функция concatenate

Для объединения массивов вдоль строго определенной оси можно воспользоваться функцией concatenate(). Например, возьмем два трехмерных массива:

И объединим их по каждой из осей:

Объекты r_ и c_

Еще один способ объединения и создания массивов – это использование специальных объектов r_ и c_. Например, объект r_ создает копии массивов, следующими способами:

По аналогии работает и второй объект c_, только объединение выполняется по второй оси axis1:

Разделение массивов

Массивы в NumPy можно не только объединять, но и разделять. Для этого существуют специальные функции hsplit и vsplit. Рассмотрим их работу на простых примерах. Пусть имеется одномерный массив из 10 элементов:

И мы хотим разделить его на две равные части. Это реализуется с помощью функции hsplit:

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

так как 10 элементов нельзя равномерно разбить на 3 части.

Также ошибка будет и при разбиении этого массива по вертикали:

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

а, затем, разобьем по вертикали:

На выходе получим два одномерных массива длиной 5 элементов.

Эти же функции можно использовать и с многомерными массивами, например, так:

Функция array_split

Рассмотренные функции выполняют разбиение или по первой оси axis0 или по второй оси axis1. Но что если нам нужно выполнить разбиение по произвольной оси многомерного массива? Для этого существует функция array_split(). Ее работа аналогична рассмотренным выше функциям, только дополнительно указывается ось разбиения. Например:

Видео по теме

#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 уроки

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

Источник

Numpy Hstack в Python Для различных массивов

Функция numpy hstack() в Python используется для того, чтобы сложить последовательность входных массивов горизонтально (по столбцам) и сделать их единым массивом.

Numpy Hstack в Python Для различных массивов

Модуль numpy в python состоит из очень многих интересных функций. Одним из таких увлекательных и экономящих время методов является функция numpy hstack (). Много раз мы хотим сложить различные массивы в один массив, не теряя значения. И это тоже в одной строке кода. Итак, для решения этой проблемы в numpy vstack() и hstack () доступны две функции. Здесь “v” означает “Вертикальный”, а “h” – “Горизонтальный”.

В этой конкретной статье мы подробно обсудим функцию Numpy hstack(). Функция numpy.hstack() в Python используется для того, чтобы сложить последовательность входных массивов горизонтально (по столбцам) и сделать их единым массивом. Вы можете использовать hstack() очень эффективно вплоть до трехмерных массивов. Теперь достаточно разговоров; давайте перейдем непосредственно к использованию и примерам из основ.

Синтаксис

Параметры

Примечание

Нам нужен только один аргумент для этой функции: ‘tup.’ Tup известен как кортеж, содержащий массивы, которые должны быть сложены. Этот параметр является обязательным параметром, и мы должны обязательно передать значение.

Возвращаемое значение

Примеры для упрощения Numpy Hstack

Теперь мы увидели синтаксис, требуемые параметры и возвращаемое значение функции numpy stack. Давайте перейдем к разделу примеров. Здесь мы начнем с самого основного случая, а затем постепенно увеличим уровень примеров.

Пример 1: Базовый кейс для изучения работы Numpy Hstack

В этом примере 1 мы просто инициализируем, объявим два массива numpy, а затем создадим их горизонтальный стек с помощью функции stack.

Объяснение:

В приведенном выше примере мы сложили два массива numpy горизонтально (по столбцам). Во-первых, мы импортировали модуль numpy. После импорта мы инициализировали, объявили и сохранили два массива numpy в переменных ‘x и y’. После этого с помощью функции np.hstack() мы сложили или сложили два 1-D массива numpy. Здесь обратите внимание,что стек будет выполнен горизонтально (столбчатый стек). Кроме того, оба массива должны иметь одинаковую форму вдоль всех осей, кроме первой.

Пример 2: Объединение Трех 1-D Массивов По Горизонтали С Помощью функции numpy.hstack

Давайте перейдем ко второму примеру, здесь мы возьмем три 1-D массива и объединим их в один href=”https://en.wikipedia.org/wiki/Array_data_structure”>массив. href=”https://en.wikipedia.org/wiki/Array_data_structure”>массив.

Объяснение

В приведенном выше примере мы сделали все то же самое, что и в примере 1, за исключением добавления одного дополнительного массива. В примере 1 мы видим, что существует два массива. Но в этом примере мы использовали три массива “x, y, z”. И с помощью np.hstack() мы соединили их вместе по столбцам (горизонтально).

Пример 3: Объединение 2-D Массивов Numpy С Numpy.hstack

Объяснение:

В приведенном выше примере мы инициализировали и объявили два 2-D массива. И мы сохранили их в двух переменных, ‘x,y’ соответственно. После хранения переменных в двух разных массивах мы использовали функцию, чтобы объединить два 2-D массива и сделать их одним 2-d массивом. Здесь нам нужно убедиться, что форма обоих входных массивов должна быть одинаковой. Если формы различны, то мы получим ошибку значения.

Пример 4: Укладка 3-D массива Numpy с помощью функции hstack

Объяснение

Мы можем использовать эту функцию для укладки или объединения 3-D массива по горизонтали (по столбцам). Вместо 1-D массива или 2-D массива в приведенном выше примере мы объявили и инициализировали два 3-D массива. После инициализации мы сохранили их в двух переменных, ‘x и y’ соответственно. После части хранения мы использовали эту функцию для укладки 3-D массива горизонтально (по столбцам).

Примечание: Форма входных массивов должна быть одинаковой.

Можем ли Мы Комбинировать Массивы Numpy с различными формами с Помощью Hstack

Простой односложный ответ-Нет. Давайте докажем это на одном из примеров.

Объяснение:

В приведенном выше случае мы получаем ошибку значения. Здесь, во-первых, мы импортировали необходимый модуль. После этого мы инициализировали два массива и сохранили их в двух разных переменных. Здесь следует отметить, что в переменной ” x ” массив имеет два элемента. Но в переменной ‘y’ массив имеет три элемента. Таким образом, мы видим, что форма обоих массивов не одинакова. Что является основным требованием при работе с этой функцией. Вот почему мы получаем ошибку значения.

Разница между Np.Hstack() и Np.Concatenate()

NumPy concatenate похож на более гибкую модель np.hstack. NumPy concatenate также объединяет массивы NumPy, но он может объединять массивы вместе либо вертикально, либо даже горизонтально. Таким образом, NumPy concatenate получает возможность объединять массивы вместе, как np.hstack плюс np.vstack. Как действует np.concatenate, зависит от того, как вы используете параметр axis из синтаксиса.

Разница между numpy hstack() и vstack()

NumPy hstack и NumPy vstack похожи друг на друга, потому что они оба объединяют массивы NumPy вместе. Существенное различие заключается в том, что np.hstack объединяет массивы NumPy по горизонтали, а np.vstack-по вертикали.

Однако, помимо этого, синтаксис и поведение очень похожи.

Должно ли количество столбцов и строк быть одинаковым?

Column: Нет, если вы используете NumPy hstack, входные массивы могут иметь разное количество столбцов.Rows: Если вы используете NumPy hstack, входные массивы должны содержать точно такое же количество строк.

Вывод

В этой статье мы подробно изучили различные аспекты, такие как синтаксис, функционирование и случаи этого hstack. Numpy.hstack () – это функция, которая помогает сложить входную последовательность горизонтально так, чтобы получился один сложенный массив. Это может быть полезно, когда мы хотим сложить различные массивы в один столбец (горизонтально). Мы можем использовать эту функцию вплоть до ndarrays, но рекомендуется использовать ее до 3-D массивов.

Однако, если у вас есть какие-либо сомнения или вопросы, дайте мне знать в разделе комментариев ниже. Я постараюсь помочь вам как можно скорее.

Источник

Python массивы. Библиотека NumPy

Библиотека NumPy ( Numerical Python ) считается основной реализацией массивов Python. Она представляет высокопроизводительный, полнофункциональный тип n-мерного массива, который называется ndarray ( array ). Операции с array выполняются на два порядка быстрее, чем операции со списками. Многие популярные библиотеки data science, такие как pandas, SciPy, Keras и другие, построены на базе NumPy или зависят от нее.

1. Создание массива в Python

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

>>> b = [[5, 6, 10], [25, 64, 17], [14, 25, 14]]
>>> mas = np.array (b)
>>> mas
array([[ 5, 6, 10],
[25, 64, 17],
[14, 25, 14]])

NumPy автоматически форматирует array на основание количества их измерений и выравнивает столбцы в каждой строке.

Список так же можно передавать напрямую переменной:

>>> numbers = np.array ([ 1, 5, 47, 78])
>>> numbers
array([ 1, 5, 47, 78])

2. Атрибуты array

2.1. Определение типа элементов array

Для проверки типа элемента array можно воспользоваться атрибутом dtype :

2.2. Определение размерности array

>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1. ndim
2
>>> numbers_1. shape
(2, 3)

В примере numbers_1 состоит из двух строк и трех столбцов.

2.3. Определение количества и размера элементов

Количество элементов в массиве можно получить с помощью атрибута size.

>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1. size
6

>>> numbers_1. itemsize
4

Для компиляторов C с 32-разрядным int, размер равен 4. Если у вас 64-разрядный, у вас будет равен 8.

2.4. Перебор элементов array

Для перебора многомерной коллекции array можно воспользоваться циклом for:

>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> for row in numbers_1:
. for column in row:
. print(column, end=’ ‘)
. print()
.
5 7 45
14 7 9

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

>>> for i in numbers_1. flat :
. print(i, end=’ ‘)
.
5 7 45 14 7 9

3. Создание массивов в Python по диапазонам

NumPy представляет множество функций для создания массивов в заданном диапазоне. Разберем самые распространённые.

3.1. Создание диапазонов функцией arange

В библиотеке NumPy существует функция arange для создания целочисленных диапазонов, аналогичной встроенной функции range в Python.

3.2. Создание диапазонов чисел с плавающей точкой функцией linspace

Для создания диапазонов чисел с плавающей точкой можно воспользоваться функцикй limspace библиотеки NumPy.

3.3. Изменение размерности array методом reshape

Методом reshape вы можете преобразовать одномерную коллекцию в многомерную. В примере создадим коллекцию array с помощью arange со значениями от 1 до 36 и с помощью метода reshape преобразуем ее в структуру из 6 строк и 6 столбцов.

>>> import numpy as np
>>> np.arange(1, 37). reshape (6, 6)
array([[ 1, 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11, 12],
[13, 14, 15, 16, 17, 18],
[19, 20, 21, 22, 23, 24],
[25, 26, 27, 28, 29, 30],
[31, 32, 33, 34, 35, 36]])
>>> np.arange(1, 37). reshape (4, 9)
array([[ 1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14, 15, 16, 17, 18],
[19, 20, 21, 22, 23, 24, 25, 26, 27],
[28, 29, 30, 31, 32, 33, 34, 35, 36]])

Во втором примере мы преобразовали в структуру 4 строк и 9 столбцов.

Функция zeros создает коллекцию содержащие 0. Первым аргументом должно быть целое число или кортеж целых чисел.

>>> import numpy as np
>>> np. zeros (7)
array([0., 0., 0., 0., 0., 0., 0.])
>>> np. zeros ((3, 3))
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])

Функция ones создает коллекцию содержащие 1.

>>> import numpy as np
>>> np. ones ((3, 3))
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])

>>> import numpy as np

>>> np. ones ((3, 3), dtype=int )
array([[1, 1, 1],
[1, 1, 1],
[1, 1, 1]])
>>> np. zeros ((3, 3), dtype=int )
array([[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])

>>> import numpy as np
>>> np. full ((3, 4), 55)
array([[55, 55, 55, 55],
[55, 55, 55, 55],
[55, 55, 55, 55]])
>>> np. full ((2, 4), 21.2)
array([[21.2, 21.2, 21.2, 21.2],
[21.2, 21.2, 21.2, 21.2]])

3.5. Вывод больших коллекций array

4. Операторы array

4.1. Арифметические операции c массивами в Python

Арифметические операции с array выполняются поэлементно, то есть применяются к каждому элементу массива. Пример, если мы умножаем массив на 3, то каждый элемент будет умножен на 3. Так же и с остальными арифметическими операциями.

>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1 * 3
array([[ 15, 21, 135],
[ 42, 21, 27]])
>>> numbers_1 ** 3
array([[ 125, 343, 91125],
[ 2744, 343, 729]], dtype=int32)
>>> numbers_1
array([[ 5, 7, 45],
[14, 7, 9]])

А вот расширенное присваивание изменяет каждый элемент левого операнда:

>>> import numpy as np
>>> numbers_1 = np.array([[5, 7, 45], [14, 7, 9]])
>>> numbers_1 += 10
>>> numbers_1
array([[15, 17, 55],
[24, 17, 19]])

4.2. Арифметические операции между коллекциями array

С коллекциями array можно выполнять арифметические операции, если они имеют одинаковые размеры. Результатом будет новая коллекция array :

4.3. Сравнение коллекция array

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

>>> import numpy as np
>>> numbers_1 = np.array([2, 4, 6, 8, 10])
>>> numbers_2 = np.array([1, 5, 6, 7, 12])
>>> numbers_1 > numbers_2
array([ True, False, False, True, False])
>>> numbers_1 == numbers_2
array([False, False, True, False, False])
>>> numbers_1 >= 5
array([False, False, True, True, True])

В результате сравнений создаются коллекции array с логическими значениями ( True или False), каждое из которых означает результат сравнения каждого элемента.

5. Вычислительные методы NumPy

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

>>> import numpy as np
>>> grades = np.array([[3, 4, 5, 4], [2, 5, 4, 5], [5, 5, 4, 5]])
>>> grades
array([[3, 4, 5, 4],
[2, 5, 4, 5],
[5, 5, 4, 5]])
>>> grades. min()
2
>>> grades. max()
5
>>> grades. sum()
51
>>> grades. mean()
4.25
>>> grades. std()
0.924211375534118
>>> grades. var()
0.8541666666666666

Если axis=0, выполняется вычисления по всем значениям строк внутри каждого столбца.

Если axis=1, выполняется вычисления со всеми значениями столбца внутри каждой отдельной строки.

6. Индексирование и сегментация массивов в Python

Для одномерных коллекций array применяются, операции сегментации и индексирования, описанные в разделе «Сегментация последовательностей в Python». Ниже разберем сегментацию с двумерными коллекциями array.

Выбор элемента двумерной коллекции array

Для выбора элемента двумерной коллекции array укажите кортеж с индексами строки и столбца элемента в квадратных скобках.

>>> import numpy as np
>>> grades = np.array([[3, 4, 5, 4], [2, 5, 4, 5], [5, 5, 4, 5], [5, 4, 5, 3]])
>>> grades
array([[3, 4, 5, 4],
[2, 5, 4, 5],
[5, 5, 4, 5],
[5, 4, 5, 3]])
>>> grades[ 1, 2 ] # строка 1, столбец 2
4

Выбор подмножества строк двумерной коллекции array

Для выбора одной строки укажите в квадратных скобках только один индекс:

>>> grades[ 2 ]
array([5, 5, 4, 5])

Для выбора нескольких строк используйте синтаксис сегмента:

>>> grades[ 1:3 ]
array([[2, 5, 4, 5],
[5, 5, 4, 5]])

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

>>> grades[[ 1, 3 ]]
array([[2, 5, 4, 5],
[5, 4, 5, 3]])

Выбор подмножества столбцов двумерной коллекции array

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

>>> grades[ :, 1 ]
array([4, 5, 5, 4])

Двоеточие указывает какие строки в столбце должны выбираться. В нашем случает » : » является сегментом и выбираются все строки. После запятой мы указали 1, значит выбрали столбец номер два.

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

>>> grades[:, 1:3 ]
array([[4, 5],
[5, 4],
[5, 4],
[4, 5]])

Для выбора конкретных столбцов используйте список индексов этих строк:

>>> grades[:, [0, 2, 3] ]
array([[3, 5, 4],
[2, 4, 5],
[5, 4, 5],
[5, 5, 3]])

7. Глубокое копирование. Метод copy

>>> import numpy as np
>>> numbers_1 = np.array([21, 25, 12, 1, 78])
>>> numbers_1
array([21, 25, 12, 1, 78])
>>> numbers_2 = numbers_1. copy()
>>> numbers_2
array([21, 25, 12, 1, 78])

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

8. Изменение размеров и транспонирование массива в Python

В NumPy существует много возможностей для изменения размера массивов.

8.1. Метод resize

Метод resize изменяет размер исходной коллекции array:

>>> import numpy as np
>>> numbers = np.array([21, 25, 12, 1, 78, 77])
>>> numbers
array([21, 25, 12, 1, 78, 77])
>>> numbers. resize(3, 2)
>>> numbers
array([[21, 25],
[12, 1],
[78, 77]])

8.2. Методы flatten и ravel

>>> import numpy as np
>>> numbers = np.array([21, 25, 12, 1, 78])
>>> numbers_fl = numbers. flatten()
>>> numbers_fl
array([21, 25, 12, 1, 78])

Чтобы проверить что numbers и numbers_fl не используют общие данные изменим элемент numbers_fl и выведем оба массива:

Значение в numbers_fl изменилось, значит массивы уже не связаны между собой.

>>> numbers
array([21, 25, 12, 1, 78])
>>> numbers_ra = numbers. ravel()
>>> numbers_ra
array([21, 25, 12, 1, 78])

Чтобы проверить использование общих данных, изменим один элемент numbers_ra:

В результате значения поменялись в обоих массивах.

8.3. Транспонирование строк и столбцов

С помощью атрибута T вы можете быстро транспонировать строки и столбцы маcсива, то есть сделать так чтобы строки стали столбцами, а столбцы строками.

>>> import numpy as np
>>> numbers = np.array([[45, 65, 48], [78, 45, 62]])
>>> numbers
array([[45, 65, 48],
[78, 45, 62]])
>>> numbers. T
array([[45, 78],
[65, 45],
[48, 62]])

Транспонирование не изменяет исходную коллекцию array.

8.4. Горизонтальное и вертикальное дополнение. Функции hstack и vstack

Добавление новых строк или столбцов, называется горизонтальным или вертикальным дополнением. Допустим у нас есть две коллекции array, и мы хотим объединить их в одну. Для этого можно воспользоваться функцией hstack() из библиотеки NumPy. Функцие hstack() передается кортеж с объединяемыми коллекциями:

>>> import numpy as np
>>> numbers_1 = np.array([21, 25, 12, 1, 78])
>>> numbers_2 = np.array([17, 54, 55, 24, 78])
>>> np. hstack (( numbers_1, numbers_2 ))
array([21, 25, 12, 1, 78, 17, 54, 55, 24, 78])

В случае если нам требуется объединить массивы добавлением, можно воспользоваться функцией vstack() :

>>> np. vstack (( numbers_1, numbers_2 ))
array([[21, 25, 12, 1, 78],
[17, 54, 55, 24, 78]])

Источник