Массивы (матрицы) в python

Добро пожаловать в NumPy!

NumPy (NumericalPython) — это библиотека Python с открытым исходным кодом, которая используется практически во всех областях науки и техники. Это универсальный стандарт для работы с числовыми данными в Python, и он лежит в основе научных экосистем Python и PyData. В число пользователей NumPy входят все — от начинающих программистов до опытных исследователей, занимающихся самыми современными научными и промышленными исследованиями и разработками. API-интерфейс NumPy широко используется в пакетах Pandas, SciPy, Matplotlib, scikit-learn, scikit-image и в большинстве других научных и научных пакетов Python.

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

Узнайте больше о NumPy здесь!

GIF черезgiphy

Установка NumPy

Чтобы установить NumPy, я настоятельно рекомендую использовать научный дистрибутив Python. Если вам нужны полные инструкции по установке NumPy в вашей операционной системе, вы можетенайти все детали здесь,

Если у вас уже есть Python, вы можете установить NumPy с помощью

conda install numpy

или

pip install numpy

Если у вас еще нет Python, вы можете рассмотреть возможность использованияанаконда, Это самый простой способ начать. Преимущество этого дистрибутива в том, что вам не нужно слишком беспокоиться об отдельной установке NumPy или каких-либо основных пакетов, которые вы будете использовать для анализа данных, таких как pandas, Scikit-Learn и т. Д.

Если вам нужна более подробная информация об установке, вы можете найти всю информацию об установке наscipy.org,

фотоАдриеннотPexels

Если у вас возникли проблемы с установкой Anaconda, вы можете ознакомиться с этой статьей:

Как импортировать NumPy

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

Чтобы начать использовать NumPy и все функции, доступные в NumPy, вам необходимо импортировать его. Это можно легко сделать с помощью этого оператора импорта:

import numpy as np

(Мы сокращаем «numpy» до «np», чтобы сэкономить время и сохранить стандартизированный код, чтобы любой, кто работает с вашим кодом, мог легко его понять и запустить.)

В чем разница между списком Python и массивом NumPy?

NumPy предоставляет вам огромный выбор быстрых и эффективных числовых опций. Хотя список Python может содержать разные типы данных в одном списке, все элементы в массиве NumPy должны быть однородными. Математические операции, которые должны выполняться над массивами, были бы невозможны, если бы они не были однородными.

Зачем использовать NumPy?

фотоPixabayотPexels

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

Что такое массив?

Массив является центральной структурой данных библиотеки NumPy. Это таблица значений, которая содержит информацию о необработанных данных, о том, как найти элемент и как интерпретировать элемент. Он имеет сетку элементов, которые можно проиндексировать в Все элементы имеют одинаковый тип, называемыймассив dtype(тип данных).

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

Одним из способов инициализации массивов NumPy является использование вложенных списков Python.

a = np.array(, , ])

Мы можем получить доступ к элементам в массиве, используя квадратные скобки. Когда вы получаете доступ к элементам, помните, чтоиндексирование в NumPy начинается с 0, Это означает, что если вы хотите получить доступ к первому элементу в вашем массиве, вы получите доступ к элементу «0».

print(a)

Выход:

Python lists vs arrays

Lists	Arrays
Python lists are flexible and can hold arbitrary data.	Python arrays are just a thin wrapper on C arrays.
The list is part of python, so they do not need to be declared first.	Arrays need to be imported or declared first from other libraries(i.e. numpy).
It cannot directly handle arithmetic operations.	Can directly handle arithmetic operations.
Preferred for shorter sequences of data items.	Preferred for longer sequences of data items.
Greater flexibility allows easy modification of data.	Less flexibility since addition, deletion has to be done element-wise.
Consume larger memory for easy addition of elements.	Comparatively more compact in memory size.

Использование только с условием

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

import random
import numpy as np

a = np.random.randn(2, 3)
b = np.where(a > 0)
print(b)

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

(array(), array())

Если вы внимательно посмотрите, b теперь представляет собой кортеж из множества массивов. И в каждом массиве находится положительный элемент. Что это значит? Всякий раз, когда мы предоставляем только условие, эта функция фактически эквивалентна np.asarray.nonzero().

В нашем примере np.asarray (a> 0) вернет логический массив после применения условия, а np.nonzero (arr_like) вернет индексы ненулевых элементов arr_like.

Рассмотрим более простой пример:

import numpy as np

a = np.arange(10)

b = np.where(a < 5, a, a * 10)

print(a)
print(b)

Здесь условием является <5, что будет массивом типа numpy , x – это массив a, а y – массив a * 10. Итак, мы выбираем из только если a <5, и от a * 10, если a> 5.

Таким образом, все элементы> = 5 преобразуются путем умножения на 10. Это действительно то, что мы получаем!

Reverse a List Array in Python

As we already discussed Lists and Arrays are similar in Python. Where the major difference among the two is that arrays only allow items of the same data type whereas lists allow them to be different.

Since Python doesn’t support conventional Arrays, we can use lists to depict the same and try to reverse them. Let us take a look at the different methods following which we can accomplish this task,

1. Using List Slicing to Reverse an Array in Python

We can reverse a list array using slicing methods. In this way, we actually create a new list in the reverse order as that of the original one. Let us see how:

#The original array
arr = 
print("Array is :",arr)

res = arr #reversing using list slicing
print("Resultant new reversed array:",res)

Output:

Array is : 
Resultant new reversed array: 

2. Using reverse() Method

Python also provides a built-in method that directly reverses the order of list items right at the original place.

Note: In this way, we change the order of the actual list. Hence, the original order is lost.

#The original array
arr = 
print("Before reversal Array is :",arr)

arr.reverse() #reversing using reverse()
print("After reversing Array:",arr)

Output:

Before reversal Array is : 
After reversing Array: 

3. Using reversed() Method

We have yet another method, which when passed with a list returns an iterable having just items of the list in reverse order. If we use the method on this iterable object, we get a new list which contains our reversed array.

#The original array
arr = 
print("Original Array is :",arr)
#reversing using reversed()
result=list(reversed(arr))
print("Resultant new reversed Array:",result)

Output:

Original Array is : 
Resultant new reversed Array: 

Разделение матрицы

Разделение одномерного массива NumPy аналогично разделению списка. Рассмотрим пример:

import numpy as np
letters = np.array()

# с 3-го по 5-ый элементы
print(letters)        # Вывод: 

# с 1-го по 4-ый элементы
print(letters)        # Вывод:    

# с 6-го до последнего элемента
print(letters)         # Вывод:

# с 1-го до последнего элемента
print(letters)          # Вывод:

# список в обратном порядке
print(letters)          # Вывод:

Теперь посмотрим, как разделить матрицу.

import numpy as np

A = np.array(, 
    ,
    ])

print(A)  # две строки, четыре столбца

''' Вывод:

 ]
'''


print(A)  # первая строка, все столбцы

''' Вывод:
` 1  4  5 12 14`
'''

print(A)  # все строки, второй столбец

''' Вывод:

'''

print(A)  # все строки, с третьего по пятый столбец
''' Вывод:

 
 ]
'''

Использование NumPy вместо вложенных списков значительно упрощает работу с матрицами. Мы рекомендуем детально изучить пакет NumPy, если вы планируете использовать Python для анализа данных.

Перестройка массива

После нарезки данных вам может понадобиться изменить их.

Например, некоторые библиотеки, такие как scikit-learn, могут требовать, чтобы одномерный массив выходных переменных (y) был сформирован как двумерный массив с одним столбцом и результатами для каждого столбца.

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

Важно знать, как изменить ваши массивы NumPy, чтобы ваши данные соответствовали ожиданиям конкретных библиотек Python. Мы рассмотрим эти два примера

Форма данных

Массивы NumPy имеют атрибут shape, который возвращает кортеж длины каждого измерения массива.

Например:

При выполнении примера печатается кортеж для одного измерения.

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

Выполнение примера возвращает кортеж с количеством строк и столбцов.

Вы можете использовать размер измерений вашего массива в измерении формы, например, указав параметры.

К элементам кортежа можно обращаться точно так же, как к массиву, с 0-м индексом для числа строк и 1-м индексом для количества столбцов. Например:

Запуск примера позволяет получить доступ к конкретному размеру каждого измерения.

Изменить форму 1D в 2D Array

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

NumPy предоставляет функцию reshape () для объекта массива NumPy, который можно использовать для изменения формы данных.

Функция reshape () принимает единственный аргумент, который задает новую форму массива. В случае преобразования одномерного массива в двумерный массив с одним столбцом кортеж будет иметь форму массива в качестве первого измерения (data.shape ) и 1 для второго измерения.

Собрав все это вместе, мы получим следующий проработанный пример.

При выполнении примера печатается форма одномерного массива, изменяется массив, чтобы иметь 5 строк с 1 столбцом, а затем печатается эта новая форма.

Изменить форму 2D в 3D Array

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

Хорошим примером являетсямодель в библиотеке глубокого обучения Keras.

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

Мы можем использовать размеры в атрибуте shape в массиве, чтобы указать количество выборок (строк) и столбцов (временных шагов) и зафиксировать количество объектов в 1

Собрав все это вместе, мы получим следующий проработанный пример.

При выполнении примера сначала печатается размер каждого измерения в двумерном массиве, изменяется форма массива, а затем суммируется форма нового трехмерного массива.

Обратитесь в массив списка в Python

Как мы уже обсуждали Списки и Массивы похожи в Python. Там, где основное различие между ними, в том, что массивы позволяют только элементы одного и того же типа данных, в то время как списки позволяют им быть разными.

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

1. Использование списка нарезка, чтобы изменить массив в Python

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

#The original array
arr = 
print("Array is :",arr)

res = arr #reversing using list slicing
print("Resultant new reversed array:",res)

Выход :

Array is : 
Resultant new reversed array: 

2. Использование метода обратного ()

Python также предоставляет встроенный метод Это непосредственно меняет порядок элементов списка прямо на исходном месте.

Примечание : Таким образом, мы меняем порядок фактического списка. Следовательно, исходный порядок потерян.

#The original array
arr = 
print("Before reversal Array is :",arr)

arr.reverse() #reversing using reverse()
print("After reversing Array:",arr)

Выход :

Before reversal Array is : 
After reversing Array: 

3. Использование обратного () метода

У нас еще один метод, Что при прохождении со списком возвращает намерение имеющих только элементы списка в обратном порядке. Если мы используем Метод на этом намечном объекте мы получаем новый список, который содержит наш обратный массив.

#The original array
arr = 
print("Original Array is :",arr)
#reversing using reversed()
result=list(reversed(arr))
print("Resultant new reversed Array:",result)

Выход :

Original Array is : 
Resultant new reversed Array: 

Ways to Print an Array in Python

Now, let us look at some of the ways to print both 1D as well as 2D arrays in Python. Note: these arrays are going to be implemented using lists.

Directly printing using the print() method

We can directly pass the name of the array(list) containing the values to be printed to the method in Python to print the same.

But in this case, the array is printed in the form of a list i.e. with brackets and values separated by commas.

arr = 
arr_2d = ,]

print("The Array is: ", arr) #printing the array
print("The 2D-Array is: ", arr_2d) #printing the 2D-Array

Output:

The Array is:  
The 2D-Array is:  , ]

Here, is a one-dimensional array. Whereas, is a two-dimensional one. We directly pass their respective names to the method to print them in the form of a list and list of lists respectively.

Using for loops in Python

We can also print an array in Python by traversing through all the respective elements using loops.

Let us see how.

arr = 
arr_2d = ,]

#printing the array
print("The Array is : ")
for i in arr:
    print(i, end = ' ')

#printing the 2D-Array
print("\nThe 2D-Array is:")
for i in arr_2d:
    for j in i:
        print(j, end=" ")
    print()

Output:

The Array is : 
2 4 5 7 9 
The 2D-Array is:
1 2 
3 4

In the code above we traverse through the elements of a 1D as well as a 2D Array using for loops and print the corresponding elements in our desired form.

Массивы в Python

Python массивы и списки представляют собой простой набор связанных значений, которые называются элементами. Обычно это любой тип данных, включая объекты или другие списки! При работе с массивами все данные должны быть одинаковыми — нельзя хранить вместе строки и целые числа. Вам почти всегда придется указывать, сколько элементов нужно хранить. Динамические массивы существуют, но проще начать с массивов фиксированной длиной.

Python несколько усложняет ситуацию. Он не всегда придерживается строгих определений структур данных. Большинство объектов в Python обычно являются списками, поэтому создавая массив, вы проделываете больше работы. Вот начальный код:

from array import array
numbers = array('i', )
print numbers

Первая строка импортирует модуль array, необходимый для работы с массивами. Вторая строка создает новый массив numbers и инициализирует его значениями 2, 4, 6 и 8. Каждому элементу присваивается целочисленное значение, называемое ключом или индексом. Ключи начинаются с нуля, поэтому будет обращаться к первому элементу (2):

itypecodePythonPythonPythonC-массивахPython

Нельзя хранить элементы разных типов в этих массивах. Допустим, вы захотели сохранить строку «makeuseof.com»:

numbers = array('i', )

Это вызовет исключение при работе с Python массивом строк:

print numbers

Каждый язык программирования реализует цикл, который идеально подходит для итерации (циклизации) над элементами списка.

Наиболее распространенные циклы while и for. Python делает это еще проще, предоставляя цикл for in:

for number in numbers:
    print number

Обратите внимание на то, что вам не нужно обращаться к элементам по их ключу. Это лучший способ работы с массивом

Альтернативный способ перебора списка — это цикл for:

for i in range(len(numbers)):
    print numbers

Этот пример делает то же самое, что и предыдущий. Но в нем нужно указать количество элементов в массиве (len (cars)), а также передать i в качестве ключа. Это почти тот же код, который выполняется в цикле for in. Этот способ обеспечивает большую гибкость и выполняется немного быстрее (хотя цикла for in в большинстве случаев более чем достаточно).

Python reshape of a multidimensional array

Now, we can see how to reshape of a multidimensional array in python.

• In this example, I have imported a module called numpy as np. The NumPy library is used to work with an array.
• And assigned a variable x as x = np.array(,,,]).
• The np.array is used to find the dimension of an array, and for the variable array, I have assigned it as array = x.reshape(4, 2, 2).
• The reshape() function is used to give a new shape for an array without changing the data.
• The (4,2,2) 4 is no of elements in the array 2 is the row and another 2 is a column, to get the output I have used print(array).

Example:

In the below screenshot, you can see the output as reshaped array.

Python reshape of a multidimensional array

How to access array elements?

You can access any array item by using its index.

The syntax is

 arrayName 

For example,

import array
balance = array.array('i', )
print(balance)

Output:

200

The following image illustrates the basic concept of accessing arrays items by their index.

Accessing Array Item

Here, we have accessed the second value of the array using its index, which is 1. The output of this will be 200, which is basically the second value of the balanced array.

The array index starts with 0. You can also access the last element of an array using the -1 index.

Example:

import array as myarray
abc = myarray.array('d', )
print("Array first element is:",abc) 
print("Array last element is:",abc)
 

Output:

Array first element is: 2.5
Array last element is: 6.7

You can also access elements by using the ‘:’ operator as shown in below Python arrays examples.

Example:

import array as myarray
abc= myarray.array('q',) 
print(abc)
print(abc)
 

Output:

array('q', )                                                                                                                         
array('q', )

This operation is called a slicing operation.

Python index array

Here, we can see index array in python.

• In this example, I have imported a module called numpy as np. The NumPy library is used to work with an array.
• And assigned a variable array as array = np.arange(20,2,-2).
• The np.arange is an inbuilt numpy function that returns a ndarray object containing a spaced value with a defined interval.
• The (20,2,-2) is the range given between 20 to 2 with the difference value -2.
• To get the output I have used print(array).

Example:

We can see the output as the array from range 20 to 2 with 2 difference value between them. You can refer to the below screenshot for the output.

Python index array

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

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

Давайте рассмотрим две наиболее популярные функции, которые вам могут понадобиться или с которыми вы столкнетесь.

Вертикальный стек

Имея два или более существующих массива, вы можете сложить их вертикально, используя функцию vstack ().

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

Это продемонстрировано в примере ниже.

Выполнение примера сначала печатает два отдельно определенных одномерных массива. Массивы вертикально сложены, что приводит к новому массиву 2 × 3, содержимое и форма которого печатаются.

Горизонтальный стек

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

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

Это продемонстрировано в примере ниже.

Выполнение примера сначала печатает два отдельно определенных одномерных массива. Затем массивы располагаются горизонтально, что приводит к созданию нового одномерного массива с 6 элементами, содержимое и форма которого печатаются

Reversing an Array of Array Module in Python

Even though Python doesn’t support arrays, we can use the Array module to create array-like objects of different data types. Though this module enforces a lot of restrictions when it comes to the array’s data type, it is widely used to work with array data structures in Python.

Now, let us see how we can reverse an array in Python created with the Array module.

1. Using reverse() Method

Similar to lists, the method can also be used to directly reverse an array in Python of the Array module. It reverses an array at its original location, hence doesn’t require extra space for storing the results.

import array

#The original array
new_arr=array.array('i',)
print("Original Array is :",new_arr)

#reversing using reverse()
new_arr.reverse()
print("Reversed Array:",new_arr)

Output:

Original Array is : array('i', )
Resultant new reversed Array: array('i', )

2. Using reversed() Method

Again, the method when passed with an array, returns an iterable with elements in reverse order. Look at the example below, it shows how we can reverse an array using this method.

import array

#The original array
new_arr=array.array('i',)
print("Original Array is :",new_arr)

#reversing using reversed()
res_arr=array.array('i',reversed(new_arr))
print("Resultant Reversed Array:",res_arr)

Output:

Original Array is : array('i', )
Resultant Reversed Array: array('i', )

Implementing MergeSort and QuickSort

Here, we investigate two other commonly used Sorting techniques used in actual practice, namely the MergeSort and the QuickSort algorithms.

1. MergeSort Algorithm

The algorithm uses a bottom-up Divide and Conquer approach, first dividing the original array into subarrays and then merging the individually sorted subarrays to yield the final sorted array.

In the below code snippet, the method does the actual splitting into subarrays and the perform_merge() method merges two previously sorted arrays into a new sorted array.

import array

def mergesort(a, arr_type):
    def perform_merge(a, arr_type, start, mid, end):
        # Merges two previously sorted arrays
        # a and a
        tmp = array.array(arr_type, )
        def compare(tmp, i, j):
            if tmp <= tmp:
                i += 1
                return tmp
            else:
                j += 1
                return tmp
        i = start
        j = mid + 1
        curr = start
        while i<=mid or j<=end:
            if i<=mid and j<=end:
                if tmp <= tmp:
                    a = tmp
                    i += 1
                else:
                    a = tmp
                    j += 1
            elif i==mid+1 and j<=end:
                a = tmp
                j += 1
            elif j == end+1 and i<=mid:
                a = tmp
                i += 1
            elif i > mid and j > end:
                break
            curr += 1


    def mergesort_helper(a, arr_type, start, end):
        # Divides the array into two parts
        # recursively and merges the subarrays
        # in a bottom up fashion, sorting them
        # via Divide and Conquer
        if start < end:
            mergesort_helper(a, arr_type, start, (end + start)//2)
            mergesort_helper(a, arr_type, (end + start)//2 + 1, end)
            perform_merge(a, arr_type, start, (start + end)//2, end)


    # Sorts the array using mergesort_helper
    mergesort_helper(a, arr_type, 0, len(a)-1)

Test Case:

a = array.array('i', )
print('Before MergeSort ->', a)
mergesort(a, 'i')
print('After MergeSort ->', a)

Output:

Before MergeSort -> array('i', )
After MergeSort -> array('i', )

2. QuickSort Algorithm

This algorithm also uses a Divide and Conquer strategy, but uses a top-down approach instead, first partitioning the array around a pivot element (here, we always choose the last element of the array to be the pivot).

Thus ensuring that after every step, the pivot is at its designated position in the final sorted array.

After ensuring that the array is partitioned around the pivot (Elements lesser than the pivot are to the left, and the elements which are greater than the pivot are to the right), we continue applying the function to the rest of the array, until all the elements are at their respective position, which is when the array is completely sorted.

Note: There are other approaches to this algorithm for choosing the pivot element. Some variants choose the median element as the pivot, while others make use of a random selection strategy for the pivot.

def quicksort(a, arr_type):
    def do_partition(a, arr_type, start, end):
        # Performs the partitioning of the subarray a
        
        # We choose the last element as the pivot
        pivot_idx = end
        pivot = a

        # Keep an index for the first partition
        # subarray (elements lesser than the pivot element)
        idx = start - 1

        def increment_and_swap(j):
            nonlocal idx
            idx += 1
            a, a = a, a

         < pivot]
        
        # Finally, we need to swap the pivot (a with a)
        # since we have reached the position of the pivot in the actual
        # sorted array
        a, a = a, a

        # Return the final updated position of the pivot
        # after partitioning
        return idx+1

    def quicksort_helper(a, arr_type, start, end):
        if start < end:
            # Do the partitioning first and then go via
            # a top down divide and conquer, as opposed
            # to the bottom up mergesort
            pivot_idx = do_partition(a, arr_type, start, end)
            quicksort_helper(a, arr_type, start, pivot_idx-1)
            quicksort_helper(a, arr_type, pivot_idx+1, end)

    quicksort_helper(a, arr_type, 0, len(a)-1)

Here, the method does the step of the Divide and Conquer approach, while the method partitions the array around the pivot and returns the position of the pivot, around which we continue to recursively partition the subarray before and after the pivot until the entire array is sorted.

Test Case:

b = array.array('i', )
print('Before QuickSort ->', b)
quicksort(b, 'i')
print('After QuickSort ->', b)

Output:

Before QuickSort -> array('i', )
After QuickSort -> array('i', )

Python change shape of a 1D array to a 3D array

Now, we can see how to change the shape of a 1D array to a 3D array in python.

• In this example, I have imported a module called numpy as np and assigned, the variable array as array = np.array(). The np.array is used to get the dimension of an array.
• To change the shape of an array I have created another variable as array_3d and assigned array_3d = array.reshape(2, 3, 2).
• The reshape() function is used to get the new shape for an array without changing the data. To get the output I have used print(array_3d).

Example:

The input array was of 1d array and in the output you can see 3d array. You can refer to the below screenshot for the output.

Python convert 1D array to 3D array

Индексирование массивов

Когда ваши данные представлены с помощью массива NumPy, вы можете получить к ним доступ с помощью индексации.

Давайте рассмотрим несколько примеров доступа к данным с помощью индексации.

Одномерное индексирование

Как правило, индексирование работает так же, как вы ожидаете от своего опыта работы с другими языками программирования, такими как Java, C # и C ++.

Например, вы можете получить доступ к элементам с помощью оператора скобок [], указав индекс смещения нуля для значения, которое нужно получить.

При выполнении примера печатаются первое и последнее значения в массиве.

Задание целых чисел, слишком больших для границы массива, приведет к ошибке.

При выполнении примера выводится следующая ошибка:

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

Например, индекс -1 относится к последнему элементу в массиве. Индекс -2 возвращает второй последний элемент вплоть до -5 для первого элемента в текущем примере.

При выполнении примера печатаются последний и первый элементы в массиве.

Двумерное индексирование

Индексация двумерных данных аналогична индексации одномерных данных, за исключением того, что для разделения индекса для каждого измерения используется запятая.

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

Например, мы можем получить доступ к первой строке и первому столбцу следующим образом:

При выполнении примера печатается первый элемент в наборе данных.

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

Это печатает первый ряд данных.

Массив нарезки

Все идет нормально; Создание и индексация массивов выглядит знакомо.

Теперь мы подошли к нарезке массивов, и это одна из функций, которая создает проблемы для начинающих массивов Python и NumPy.

Структуры, такие как списки и массивы NumPy, могут быть нарезаны. Это означает, что подпоследовательность структуры может быть проиндексирована и извлечена.

Это наиболее полезно при машинном обучении при указании входных и выходных переменных или разделении обучающих строк из строк тестирования.

Нарезка задается с помощью оператора двоеточия ‘:’ с ‘от’ а также ‘в‘Индекс до и после столбца соответственно. Срез начинается от индекса «от» и заканчивается на один элемент перед индексом «до».

Давайте рассмотрим несколько примеров.

Одномерная нарезка

Вы можете получить доступ ко всем данным в измерении массива, указав срез «:» без индексов.

При выполнении примера печатаются все элементы в массиве.

Первый элемент массива можно разрезать, указав фрагмент, который начинается с индекса 0 и заканчивается индексом 1 (один элемент перед индексом «до»)

Выполнение примера возвращает подмассив с первым элементом.

Мы также можем использовать отрицательные индексы в срезах. Например, мы можем нарезать последние два элемента в списке, начав срез с -2 (второй последний элемент) и не указав индекс «до»; это берет ломтик до конца измерения.

Выполнение примера возвращает подмассив только с двумя последними элементами.

Двумерная нарезка

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

Разделение функций ввода и вывода

Распространено загруженные данные на входные переменные (X) и выходную переменную (y).

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

Для входных объектов мы можем выбрать все строки и все столбцы, кроме последнего, указав ‘:’ в индексе строк и: -1 в индексе столбцов.

Для выходного столбца мы можем снова выбрать все строки, используя ‘:’, и индексировать только последний столбец, указав индекс -1.

Собрав все это вместе, мы можем разделить 3-колоночный 2D-набор данных на входные и выходные данные следующим образом:

При выполнении примера печатаются разделенные элементы X и y

Обратите внимание, что X — это двумерный массив, а y — это одномерный массив

Сплит поезд и тестовые ряды

Обычно загруженный набор данных разбивают на отдельные наборы поездов и тестов.

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

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

Тестовым набором данных будут все строки, начиная с точки разделения до конца измерения.

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

При выполнении примера выбираются первые две строки для обучения и последняя строка для набора тестов.