Многомерный массив javascript: Многомерные массивы в JS — CodeChick

Как перебрать многомерный массив?

Главная » Изучение

Изучение

На чтение 4 мин Просмотров 153 Опубликовано 20.06.2022

Многомерные массивы — это массивы, имеющие более одного измерения. Например, простой массив — это одномерный массив, матрица — это двумерный массив, а куб или прямоугольный параллелепипед — это трехмерный массив, но как визуализировать массивы с более чем 3 измерениями и как перебирать элементы из этих массивов? Это просто, просто подумайте о любом многомерном массиве как о наборе массивов более низких измерений.

n-D array = Collection of (n-1)D arrays

Например, матрица или двумерный массив — это набор одномерных массивов.

2D-массив представляет собой набор 1D-массивов

Точно так же вы можете визуализировать трехмерные массивы и другие многомерные массивы.

Содержание

1. Как перебирать элементы многомерного массива
2. Пример 1: Итерация по двумерному массиву
3. Пример 2: Итерация по 3D-массиву

Можно заметить, что только одномерный массив содержит элементы, а многомерный массив содержит массивы меньшего размера.

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

Пример 1: Итерация по двумерному массиву

С++

#include <bits/stdc++.h>

usingnamespacestd;

 

intmain()

{

    

    intn = 3;

    intm = 3;

    intarr[][3]

        = { { 3, 2, 7 }, { 2, 6, 8 }, { 5, 1, 9 } };

 

    

    for(inti = 0; i < n; i++) {

 

        

        for(intj = 0; j < m; j++) {

 

            

            cout << arr[i][j] << " ";

        }

        

cout << endl;

    }

    return0;

}

Выход

3 2 7 
2 6 8 
5 1 9

Пример 2: Итерация по 3D-массиву

С++

#include <bits/stdc++. h>

usingnamespacestd;

 

intmain()

{

    

    intx = 2, y = 2, z = 2;

    intarr[][3][2] = { { { 1, 2 }, { 3, 4 } },

                        { { 5, 6 }, { 7, 8 } } };

 

    

    for(

inti = 0; i < x; i++) {

        cout << "Inside "<< i + 1

             << " 2D array in 3-D array"<< endl;

 

        

        for(intj = 0; j < y; j++) {

            cout << "Inside "

<< j + 1

                 << " 1D array of the 2-D array"<< endl;

 

            

            for(intk = 0; k < z; k++) {

                cout << arr[i][j][k] << " ";

            }

            

cout << endl;

        }

        cout << endl;

    }

    return0;

}

Выход

Inside 1 2D array in 3-D array
Inside 1 1D array of the 2-D array
1 2 
Inside 2 1D array of the 2-D array
3 4 

Inside 2 2D array in 3-D array
Inside 1 1D array of the 2-D array
5 6 
Inside 2 1D array of the 2-D array
7 8

Работа с многомерными массивами JavaScript

Массивы в языках программирования Java и C# — это упорядоченный набор данных. Он состоит из элементов, доступ к которым осуществляется при помощи индексов. Массив в языках программирования Java и C# можно представить как ленту из одинаковых по размеру ячеек. У него есть тип, определяющийся данными. Например, может быть массив чисел, строк или объектов. Потому все ячейки и одинаковы по размерам, так как в каждой из них хранится одинаковый тип данных. Если нужно хранить разные данные, тогда понадобится сделать несколько разных массивов.

Простота использования массивов в языках программирования Java и C#

То, что ячейки имеют одинаковый размер, позволяет удобно передвигаться по ним. У программиста есть индексы для доступа, но так как известно, что все данные хранятся вместе и физически находятся в определенной последовательности, то легко можно рассчитать, где размещаются нужные данные. Зная об этом и о том, сколько памяти занимает каждая ячейка, легко узнать расположение определенной информации заданного типа. Например, в ячейке хранится число, и мы знаем, что 1 ячейка занимает 8 бит, то есть один байт. Тогда, для того чтобы перейти к ячейке №3, от самого начала массива нам нужно отсчитать два байта информации, или 16 бит. Все эти правила и лимитирования при работе с массивами в языках программирования Java и C# очень удобны и помогают легко ориентироваться в данных.

Использование JavaScript и onload-события для создания…

Веб-технологии далеки от сферы искусственного интеллекта, но создание сайтов, контролирующих свое…

Массивы в Javascript и их особенности

С Javascript все обстоит иначе, и определение массива не имеет ничего общего с тем, что выше. Массив здесь — это объект. Он напоминает список элементов и обладает дополнительными свойствами и методами. Тип и размер элементов в массивах в Javascript не фиксированы, а “длина” самого массива не становится его верхней границей. Это означает, что в одном массиве могут храниться различные типы данных: числа, строки, объекты и т. д. Никто никак не контролирует с точки зрения языка то, что будет храниться в одном блоке. Размер ячеек также не зафиксирован из-за этого свойства массива Javascript. Есть понятие “длины”, но это просто некое свойство объекта, с которым можно работать определенным образом. Существует также понятие ассоциативного массива в Javascript. Такие объекты состоят из пар “ключ-значение”. Значения в них связаны с ключами. То есть при обращении к ним возвращается значение ключа. Ассоциативный массив в Javascript — тот, у которого в качестве ключей выступают строки.

Функция PHP array_keys: простые реляционные отношения

Строки и массивы стали практичным инструментом обработки данных, состоящих в безусловных…

Как создать массив в языке Javascript

Для того чтобы создать массив, сначала нужно объявить переменную myArray следующим образом: var myArray = [ ]. Мы получим массив без элементов. При помощи классических квадратных скобок, которые используются в большинстве языков программирования, создается пустой массив. Теперь можно с ним работать. Другой вариант — создать массив с данными и сразу же заполнить его. Это может быть перечисление городов, месяцев и другие значения. Все они будут располагаться в массиве Javascript в определенном порядке. У первого элемента индекс “0”, так как в программировании нумерация всегда начинается с нуля, индекс следующего элемента — “1” и так далее. Это тот способ создания массива при помощи квадратных скобок, который рекомендуется использовать.

Примеры применения метода JavaScript length

Длина строки, числа или иного элемента скрипта имеет существенное значение. Особенностью подхода…

Вариант создания массива при помощи конструктора

Еще вариант — это создание массива при помощи конструктора с функцией Array. В этом случае объявляется переменная, например, “а”, и при помощи ключевого слова “new” в нее помещается значение “Array”. Называть переменные простыми буквами считается не лучшей практикой, поэтому присваивать подобные значения лучше всего только для учебных целей, а не в работе с кодом. И еще одно замечание: с конструктором нужно быть внимательными и осторожными, так как при его помощи можно передавать не только перечень каких-то значений (например, строк) — в таком конструкторе иногда присутствует и только одно число. Но при этом не создается массив с данными, соответствующими этому числу. Если написать строку кода: “var a new = (5)”, то в массиве просто появятся 5 пустых ячеек. При выводе в консоль мы получим квадратные скобки с пустыми местами, отделенные запятыми. Если написать через запятую “1,3”, то получится массив с двумя элементами, первый из которых равен единице, а второй — тройке. При обращении к этому массиву он выводится в консоль как перечень элементов в следующем виде: [1, 3].

Длина массива

У массивов в Javascript есть свойство Length. Оно означает размер массива, его длину. Но этот метод не всегда верно срабатывает. В некоторых случаях реальная длина массива будем совсем другой. Поэтому программисту нужно понять и запомнить, что это свойство на самом деле не говорит о реальном количестве элементов, хотя в большинстве случаев это именно так. Length — это “индекс последнего элемента + 1”. Поэтому если сравнивать это свойство с аналогичным в языке C#, то это бы соответствовало реальности. И “индекс последнего элемента + 1” всегда бы означал количество элементов в этом массиве. Но работа с массивами в Javascript отличается от других языков программирования.

Изменение длины массива

Значение длины массива можно изменять вручную. Для примера, можно создать простой массив с тремя одинаковыми элементами и вывести в консоль длину его строки. Она будет равна трем. Если теперь мы будем обращаться к различным элементам этого массива, то будем получать их значения. Но если затем обратимся к элементу, у которого нет значения, то получим “undefined”, что означает “не определено”. И в этом случае начинается не совсем обычное поведение свойства длины массива.

Как рассчитывается количество элементов в массиве

Несмотря на то что после элемента с определенным индексом, например, третьим, уже нет других данных, можно задать значение элементу с индексом “10”. Такое значение задается элементу с абсолютно любым индексом. Тогда мы получим множество неопределяемых значений до тех пор, пока не доберемся до элемента с заданным значением. Таким образом, хотя по факту у нас может быть всего четыре элемента в массиве со множеством неопределенных между ними, длина строки при этом будет равна “11”, потому что индексом последнего элемента оказалось число “10”, а значение свойства рассчитывается как “индекс последнего элемента + 1”. Поэтому, если нужно узнать, сколько элементов с данными в массиве на самом деле, исключая неопределенные, не нужно полагаться на Length.

Особенности срабатывания свойства Length

Если в качестве примера мы снова обратимся к массиву, который задали при помощи new, и попробуем вывести его длину в консоль, то мы получим 0, так как он не содержал элементов. Но если то же свойство применить к массиву, созданному при помощи конструктора, тогда, несмотря на то, что он пустой, длина строки будет равна тому числу, которое находилось в круглых скобках. Length все равно посчитает все элементы, даже если они пустые.

Для массива, который содержал список из нескольких непустых элементов, это значение окажется равным их количеству. Значение Length можно изменять, добавляя после знака “=” желаемое значение. И если мы изменим его на какое-либо значение меньше текущего, тогда все элементы, которые будут идти за ним, отсекаются от массива. Например, если длина массива равна пяти, а Length — двум, тогда все элементы после второго пропадут при обращении к нему. Это один из простых способов отрезать часть массива, расположенную в его конце. Поиск в массиве Javascript осуществляется при помощи функции find и метода indexOf объекта Array.

Многомерные массивы и их создание

Достаточно легко создать многомерный массив в Javascript из объектов и других элементов. Так как значения элементов никак не фиксированы, то в один массив можно поместить число, объект, строку и другой массив, причем одновременно. В результате мы получим массив с четырьмя значениями, каждое из которых будет являться отдельным типом. Таким образом можно создавать многомерные массивы в Javascript.

Если в одном массиве находится несколько, то первому будет соответствовать нулевой индекс, второму — первый и так далее. То есть каждый из них будет выводиться как элемент. Двумерный массив в Javascript — это многомерный массив с 2 уровнями объявления. Существуют также трехмерные, четырехмерные и так далее. Для того чтобы получить какую-то часть массива внутри другого массива, к его элементу также нужно обратиться по индексу, например: a[0] [1]. Программист может создавать многомерные массивы в Javascript с практически бесконечным количеством элементов.

Добавление и удаление элемента массива

Так как массив — это объект, то значения его элементов являются свойствами объектов. Поэтому работать с ними можно аналогичным образом. Удаляется какой-либо элемент из массива при помощи свойства delete и обращения к индексу. В многомерных массивах при удалении какой-то их части образуется пустота, которая будет отделена запятой. Но если при удалении вы хотите, чтобы остальные значения сместились вверх и пространства между ними не оставалось, тогда для удаления элемента используется метод Splice. Он принимает два параметра. Первый — это индекс, с которого нужно начать, а второй — количество элементов, которые нужно удалить. Этот метод позволяет удалять элементы в массиве, сдвигая все последующие таким образом, что пустого пространства между ними не остается.

Добавить элемент в массив Javascript можно при помощи обращения к индексу. Новое значение уже существующему элементу присваивается так: a[0] = 5, где а — это сам элемент, в квадратных скобках располагается его индекс, а после знака “=” — новое значение. Совершенно новый элемент также добавляется при помощи индекса, который еще не задействован в массиве. Если размер массива в Javascript неизвестен, можно воспользоваться переменной Length и написать так: a[a.length] — это будет число, соответствующее “последнему индексу +1”.

Перебор и сортировка массивов в JavaScript

Для перебора массива можно пользоваться специальной формой цикла for …in. Но опытные программисты не рекомендуют применять ее. Дело в том, что если задать массив при помощи конструктора, этот метод выдаст только одну цифру. При использовании счетчика с переменной от нуля до значения длины строки в результате можно получить все элементы сразу. Сортировка массивов осуществляется при помощи метода sort. Но в этом случае исходное значение нужно сохранить, если оно еще понадобится в будущем.

Реализация многомерных массивов в JavaScript — 0 FPS

Последние несколько месяцев я работал над переносом большей части своей работы в JavaScript и, в частности, в экосистему node.js. Я надеюсь, что благодаря этому я смогу создавать более качественные демоверсии и приложения, которые легче использовать и разрабатывать.

Численные вычисления во враждебной среде

Но, несмотря на многочисленные практические преимущества работы с JavaScript (особенно с точки зрения взаимодействия с пользователем), есть еще много вещей, в которых JS просто отстой. Для меня самым болезненным из них является слабая поддержка числовых вычислений и двоичных типов данных. Эти проблемы связаны с фундаментальными ограничениями языка, а не с чем-то, что можно скрыть в библиотеке. Например, в JS есть:

• Нет передачи по значению для непримитивных типов данных
• Невозможно контролировать выравнивание памяти для членов объектов
• Нет возможности ограничить ссылки на указатели/предотвратить псевдонимы
• Нет способа гарантировать, что массивы объектов размещены на месте
• Нет перегрузки оператора
• Нет операций с массивами
• Нет инструкций SIMD и типов данных
• … и т. д.

Это плохая ситуация, но преимущества использования JS с точки зрения доступности слишком велики, чтобы их игнорировать, поэтому, по крайней мере, стоит попробовать все, что можно сделать в рамках ограничений системы. Более того, эти препятствия отнюдь не беспрецедентны в мире вычислений. В качестве поучительного примера рассмотрим язык программирования Java: Java страдает точно такими же недостатками дизайна, перечисленными выше, и все же это жизнеспособная платформа для численных вычислений с энтузиазмом в сообществе (хотя она по-прежнему далеко не так быстро, как более эффективно разработанные языки).

как Фортран/С99). Таким образом, правдоподобной гипотезой является то, что JavaScript может достичь аналогичных результатов.

Повторная реализация, скажем, LAPACK или SciPy — это огромный проект, и нецелесообразно пытаться сделать это в одной статье или даже в одной библиотеке. Чтобы сфокусировать наши запросы, давайте сначала ограничим область нашего поиска. Вместо этого давайте сегодня изучим фундаментальную проблему реализации многомерных массивов.

Многомерные массивы

Многомерные массивы являются естественным первым шагом к созданию систем для решения численных задач и, как правило, сами по себе являются полезным типом данных с приложениями в графике и зрении. В таком языке, как JavaScript, есть несколько способов

Массивы массивов

Возможно, самый популярный способ представления многомерных массивов в JavaScript — это массивы массивов. Например,

 переменная A = [[1, 0, 0],
         [0, 1, 0],
         [0, 0, 1]] 

Это подход, который использует numeric. js, и у него есть некоторые достоинства. Например, синтаксис для доступа к элементам в массиве массивов довольно прост:

 var x = A[i][j] 

И он не требует введения в язык каких-либо дополнительных структур данных или соглашений.

Однако, хотя массивы массивов и являются самым простым решением, с точки зрения производительности они катастрофичны. Наиболее очевидная проблема заключается в том, что для размещения d-мерного массива массивов с O(n) элементами на каждый элемент вам необходимо хранить дополнительные байты памяти в указателях и промежуточных массивах. Кроме того, доступ к элементу в массиве массивов требует зависимых разыменований памяти. Эти операции не могут быть легко конвейеризированы и ужасны с точки зрения производительности кэша. Если производительность хотя бы отдаленно близка к цели, то нам нужно попытаться сделать что-то лучше.

Типизированные массивы

К счастью, и в JavaScript, и в Java есть лучшая альтернатива массивам массивов: а именно, типизированные массивы.

Использование типизированного массива позволяет нам гарантировать, что данные для нашего массива расположены непрерывно без потери места. Например, вот как мы могли бы создать типизированный массив для той же матрицы, описанной ранее:

 var A = new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]) 

недостатком является то, что доступ к элементам из типизированного массива немного сложнее. Для этого нам нужно заранее договориться о том, как элементы массива располагаются в памяти. В таких языках, как C, обычно это делается в колексикографическом порядке (также известном как основной порядок строк), в то время как в других языках, таких как Fortran, используется лексикографический порядок (также называемый основным порядком столбцов). Выбор между ними абсолютно произвольный, но как только вы выберете один, вы должны его придерживаться. Тогда, предполагая основной порядок строк, мы можем получить доступ к элементу из массива, используя формулу:

 var x = A[3 * i + j] 

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

Массивы с чередованием

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

 var x = A[ c0 * i + c1 * j + ... ] 

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

 var x = A[ c1 * i + c0 * j + ... ] 

Отрицательное значение шага можно использовать для обращения оси, а изменение формы массива позволяет нам легко вырезать подмассивы из массивов более высокой размерности.

Знакомство с

ndarray

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

https://github.com/mikolalysenko/ndarray

По сути, ndarray — это объект, содержащий 4 части данных:

• данные — лежащий в основе типизированный массив
.
• shape — Форма ndarray
• шаг  – Шаг ndarray
• смещение — указатель на первый элемент в массиве

Для поиска элемента в ndarray используется формула:

 data[шаг[0] * i[0] + шаг[1] * i[1] + ... + смещение] 

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

Но быстро ли?

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

 функциональный тест (А, В) {
  для (я в диапазоне) {
    А[я] += В[я] + 0,1
    Б[я] -= А[я] * 0,5
  }
} 

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

Сводная информация о производительности алгоритма массива для различных реализаций.

Вы можете найти более подробные результаты и дальнейшие эксперименты (включая прямые сравнения с использованием numeric.js) на странице github для этого проекта:

https://github.com/mikolalysenko/ndarray-experiments

Эти результаты несколько типичны, индексация в ndarray немного медленнее, чем прямой обход типизированного массива, но ненамного. Для массивов массивов производительность становится все хуже по мере увеличения первых осей, но даже в лучшем случае они сильно отстают от структур данных, построенных на типизированных массивах.

В следующий раз

Возникает естественный вопрос: можем ли мы сделать еще лучше? И да. Ключом к дальнейшему повышению производительности является совместная пакетная обработка операций, обеспечивающая полное понимание массива. Я расскажу об этом в следующем посте, а пока вы можете взглянуть на мою текущую реализацию массовых операций над ndarrays в библиотеке cwise.

Нравится:

Нравится Загрузка…

Как соединить массивы NumPy

Как соединить массивы NumPy в Python? Вы можете использовать функцию numpy.concatenate() для объединения, слияния или объединения последовательности из двух или нескольких массивов в один массив NumPy. Конкатенация означает размещение содержимого двух или более массивов в одном массиве. В Python NumPy мы можем объединять массивы по осям (вертикальным или горизонтальным), тогда как в SQL мы соединяем таблицы на основе ключей.

Вы можете передать последовательность массивов, которые хотите соединить, с функцией concatenate() вместе с осью. Если ось не передается явно, она принимается за 0. В этой статье я объясню, как объединить массивы NumPy (ndarray) с примерами, используя такие функции, как concatenate(), stack() , hstack() , vstack() , dstack() .

Обратите внимание, что в Python NumPy ndarray  – это многомерный однородный массив элементов фиксированного размера одного типа. Вы можете создать объект ndarray, используя  NumPy.массив() .

Учебное пособие по PySpark для начинающих | Py…

Включите JavaScript

Учебное пособие по PySpark для начинающих | Примеры Python

1. Краткие примеры объединения массивов NumPy

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

# Ниже приведены краткие примеры
# Пример 1: Используйте concatenate() для объединения двух массивов
con = np.concatenate ((обр, обр1))
печать (против)
# Пример 2: Используйте concatenate() с осью
con = np.concatenate ((arr, arr1), ось = 1)
печать (против)
# Пример 3: Используйте функцию np.stack() для объединения массивов
con = np. stack((arr, arr1), ось=1)
печать (против)
# Пример 4: Использование функции np.hstack()
кон = np.hstack ((обр, обр1))
печать (против)
# Пример 5: Использование функции np.vstack()
кон = np.vstack ((обр, обр1))
печать (против)
# Пример 6: Используйте функцию np.dstack() для укладки по высоте (глубине)
con = np.dstack((обр, обр1))
печать (против)
 

Давайте рассмотрим каждый из них на примерах.

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

Используйте numpy.concatenate() для объединения содержимого двух или нескольких массивов в один массив. Эта функция принимает несколько аргументов вместе с массивами NumPy для объединения и возвращает массив Numpy ndarray . Обратите внимание, что этот метод также принимает ось в качестве другого аргумента, если он не указан, по умолчанию он равен 0.

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

импортировать numpy как np
#Создать массивы NumPy
массив = np.массив ([4, 7, 12])
arr1 = np.массив ([5, 9, 15])
# Используйте concatenate() для объединения двух массивов
con = np.concatenate ((обр, обр1))
печать (против)
 

Выход ниже выходного. Если вы заметили, он просто добавляет элементы из второго массива в первый массив и возвращает новый массив NumPy.

[ 4 7 12 5 9 15]
 

3. Используйте numpy.concatenate() с осью = 1

Вы также можете объединить два массива NumPy по столбцам, указав ось = 1. Теперь результирующий массив представляет собой широкую матрицу с большим количеством столбцов, чем строк. С axis=1 , он возвращает массив массивов (вложенный массив).

# Используйте concatenate() с осью
con = np.concatenate ((arr, arr1), ось = 1)
печать (против)
 

Выход ниже выходного.

[[ 4 5]
 [ 7 9]
 [12 15]]
 

Теперь давайте посмотрим, как объединить вложенные массивы NumPy.

# Создаем массив NumPy
массив = np. массив ([[4, 6], [9, 13]])
arr1 = np.массив ([[8, 3], [12, 19]])
# Использовать функцию np.concatenate()
con = np.concatenate ((arr, arr1), ось = 1)
печать (против)
 

Выход ниже выходного.

[[ 4 6 8 3]
 [9 13 12 19]]
 

4. Используйте функцию numpy.stack() для объединения массивов

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

# Создаем массивы NumPy
массив = np.массив ([4, 7, 12])
arr1 = np.массив ([5, 9, 15])
# Используйте функцию numpy.stack() для объединения массивов
con = np.stack((arr, arr1), ось=1)
печать (против)
 

Выход ниже выходного. Поскольку я использовал ось = 1 , она объединяется по столбцам.

[[ 4 5]
 [ 7 9]
 [12 15]]
 

5. Используйте функцию NumPy.

hstack()

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

# Создаем массивы NumPy
массив = np.массив ([4, 7, 12])
arr1 = np.массив ([5, 9, 15])
# Использовать функции NumPy.hstack()
кон = np.hstack ((обр, обр1))
печать (против)
 

Выход ниже выходного.

[ 4 7 12 5 9 15]
 

6. Используйте функцию NumPy.vstack()

Вы можете использовать numpy.vstack() для последовательного вертикального стека массивов.

# Создаем пустые массивы
массив = np.массив ([4, 7, 12])
arr1 = np.массив ([5, 9, 15])
# Использовать функцию numpy.hstack()
кон = np.vstack ((обр, обр1))
печать (против)
 

Выход ниже выходного.

[[ 4 7 12]
 [ 5 9 15]]
 

7. Используйте функцию numpy.dstack() для объединения массивов

Используйте numpy.dstack() для укладки вместе с высотой, которая совпадает с глубиной.

# Создаем массивы NumPy
массив = np.массив ([4, 7, 12])
arr1 = np.массив ([5, 9, 15])
# Используйте функцию NumPy.dstack() для укладки по высоте (глубине)
con = np.dstack((обр, обр1))
печать (против)
 

Выход ниже выходного. Этот вывод аналогичен использованию concatenate() с axis=1 .

[[[ 4 5]
  [ 7 9]
  [12 15]]]
 

8. Заключение

В этой статье я объяснил, как объединить два или несколько массивов NumPy с помощью concatenate() , stack() , hstack() , vstack() , dstack() с примерами. Конкатенация означает размещение содержимого двух или более массивов в одном массиве. В Python NumPy мы можем объединять массивы по осям (вертикальным или горизонтальным), тогда как в SQL мы соединяем таблицы на основе ключей.

Счастливого обучения!!

Связанные статьи

• Как преобразовать массив NumPy в список
• Как добавить массив NumPy?
• Функция NumPy concatenate()
• Как сортировать элементы NumPy?
• Как получить значения из массива NumPy по индексу?
• Пустой массив NumPy с примерами
• Функция NumPy fill() с примерами
• Функция NumPy where() с примерами
• Способы создания массива NumPy с примерами

Ссылки

900 https://numdoc.

No related posts.