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

Summary:

• An array is a common type of data structure wherein all elements must be of the same data type.
• Python programming, an array, can be handled by the “array” module.
• Python arrays are used when you need to use many variables which are of the same type.
• In Python, array elements are accessed via indices.
• Array elements can be inserted using an array.insert(i,x) syntax.
• In Python, arrays are mutable.
• In Python, a developer can use pop() method to pop and element from Python array.
• Python array can be converted to Unicode. To fulfill this need, the array must be a type ‘u’; otherwise, you will get “ValueError”.
• Python arrays are different from lists.
• You can access any array item by using its index.
• The array module of Python has separate functions for performing array operations.

Куда пойти отсюда?

Достаточно теории, давайте познакомимся!

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

Практические проекты – это то, как вы обостряете вашу пилу в кодировке!

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

Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.

Присоединяйтесь к моему бесплатным вебинаре «Как создать свой навык высокого дохода Python» и посмотреть, как я вырос на моем кодированном бизнесе в Интернете и как вы можете, слишком от комфорта вашего собственного дома.

Присоединяйтесь к свободному вебинару сейчас!

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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

Использование sorted() для итерируемых объектов Python

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

С помощью этого метода можно отсортировать любой итерируемый объект Python, например список или массив.

import array

# Declare a list type object
list_object = 

# Declare an integer array object
array_object = array.array('i', )

print('Sorted list ->', sorted(list_object))
print('Sorted array ->', sorted(array_object))

Вывод:

Sorted list -> 
Sorted array -> 

Проверьте, пуст ли массив NumPy

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

В следующем примере у нас есть оператор if, который проверяет наличие элементов в массиве с помощью ndarray.size, где ndarray-это любой заданный массив NumPy:

импорт numpy

a.массив()

если(a.размер):

print("The given Array is empty")

ещё:

print("The array = ", a)

Результат выглядит следующим образом:

В приведенном выше коде есть три элемента, поэтому он не пуст, и условие вернет false.

Если элементов нет, условие if станет истинным, и оно напечатает пустое сообщение.

Если наш массив равен:

a.массив([])

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

How to create arrays in Python?

In Python, we use following syntax to create arrays:

Class array.array(type code) 

For Example

import array as myarray
abc = myarray.array('d', )

The above code creates an array having integer type. The letter ‘d’ is a type code.

Following tables show the type codes:

Type code	Python type	C Type	Min size(bytes)
‘u’	Unicode character	Py_UNICODE	2
‘b’	Int	Signed char	1
‘B’	Int	Unsigned char	1
‘h’	Int	Signed short	2
‘l’	Int	Signed long	4
‘L’	Int	Unsigned long	4
‘q’	Int	Signed long long	8
‘Q’	Int	Unsigned long long	8
‘H’	Int	Unsigned short	2
‘f’	Float	Float	4
‘d’	Float	Double	8
‘i’	Int	Signed int	2
‘I’	Int	Unsigned int	2

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

Когда ваши данные представлены с помощью массива 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.

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

Добро пожаловать в 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)

Выход:

Функции, определенные для массивов¶

Алгебраические функции

Функця	Описание
isreal(x)	проверка на действительность (по элементам)
iscomplex(x)	проверка на комплексность (по элементам)
isfinite(x)	приверка элементов на числовое значение (не бесконечность и не «не число»).
isinf(x)	проверка на бесконечность (по элементам)
isnan(x)	проверка аргумента на «не число» (NaN), результат – логический массив
signbit(x)	истина, если установлен бит знака (меньше нуля)
copysign(x1, x2)	меняет знак x1 на знак x2 (по элементам
nextafter(x1, x2)	следующее в направлении x2 число, представимое в виде с плавающей точкой (по элементам)
modf(x)	дробная и целая часть числа
ldexp(x1, x2)	вычисляет y = x1 * 2**x2.
frexp(x)	разделение числа на нормированную часть и степень
absolute(x)	Calculate the absolute value element-wise.
rint(x)	округление элементов массива
trunc(x)	отбрасывание дробной части (по элементам)
floor(x)	целая часть
ceil(x)	минимальное целое большее числа
sign(x)	знаки элементов
conj(x)	комплексное сопряжение (по элементам).
exp(x)	экспонента (по элементам)
exp2(x)	2**элемент (по элементам)
log(x)	натуральный логарифм (по элементам)
log2(x)	двоичный логарифм (по элементам)
log10(x)	десятичный логарифм (по элементам)
expm1(x)	exp(x) — 1 (по элементам)
log1p(x)	Return the natural logarithm of one plus the input array, element-wise.
sqrt(x)	квадратный корень (для положительных) (по элементам)
square(x)	квадрат (по элементам)
reciprocal(x)	обратная величина (по элементам)

• x – массив
• out – место для результата

Тригонометрические функции

Все тригонометрические функции работают с радианами.

Функция	Обратная функция	Описание
sin(x)	arcsin(x)	синус (по элементам)
cos(x)	arccos(x)	косинус (по элементам)
tan(x)	arctan(x)	тангенс (по элементам)
	arctan2(x1, x2)	арктангенс x1/x2 с правильным выбором четверти (по элементам)
hypot(x1, x2)		гипотенуза по двум катетам (по элементам)
sinh(x)	arcsinh(x)	гиперболический синус (по элементам)
cosh(x)	arccosh(x)	гиперболический косинус (по элементам)
tanh(x)	arctanh(x)	гиперболический тангенс (по элементам)
deg2rad(x)	rad2deg(x)	преобразование градусов в радианы (по элементам)

• x, x1, x2 – массивы
• out – место для результата

Функции двух аргументов (бинарные функции)

Для правильной работы с логическими бинарными функциям (AND, OR) необходимо явно их записывать через функции
модуля «NumPy», а не полагаться на встроенные функции питона.

Функция	Описание
add(x1, x2)	сумма (по элементам)
subtract(x1, x2)	разность (по элементам)
multiply(x1, x2)	произведение (по элементам)
divide(x1, x2)	деление (по элементам)
logaddexp(x1, x2)	логарифм суммы экспонент (по элементам)
logaddexp2(x1, x2)	логарифм по основанию 2 от суммы экспонент (по элементам)
true_divide(x1, x2)	истинное деление (с преобразованием типов)
floor_divide(x1, x2)	деление без преобразования типов (целочисленное)
negative(x)	обратные элементы (по элементам)
power(x1, x2)	элементы первого массива в степени элементов из второго массива (по элементам)
remainder(x1, x2), mod(x1, x2), fmod(x1, x2)	остаток от деления (по элементам).
greater(x1, x2)	истина, если (x1 > x2) (по элементам).
greater_equal(x1, x2)	истина, если (x1 > =x2) (по элементам).
less(x1, x2)	истина, если (x1 < x2) (по элементам).
less_equal(x1, x2)	истина, если (x1 =< x2) (по элементам).
not_equal(x1, x2)	истина, если (x1 != x2) (по элементам).
equal(x1, x2)	истина, если (x1 == x2) (по элементам).
logical_and(x1, x2)	истина, если (x1 AND x2) (по элементам).
logical_or(x1, x2)	истина, если (x1 OR x2) (по элементам).
logical_xor(x1, x2)	истина, если (x1 XOR x2) (по элементам).
logical_not(x)	истина, если (NOT x1) (по элементам).
maximum(x1, x2)	максимум из элементов двух массивов(по элементам).

• x1, x2 – массивы
• out – место для результата

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

• accumulate() Аккумулирование результата.
• outer() Внешнее «произведение».
• reduce() Сокращение.
• reduceat() Сокращение в заданных точках.

Методы accumulate(), reduce() и reduceat() принимают необязательный аргумент — номер размерности, используемой
для соответствующего действия. По умолчанию применяется нулевая размерность.

Реализация Mergeort и Quicksort

Здесь мы расследуем два других обычно используемых метода сортировки, используемые в реальной практике, а именно МЕРГОРТ и QuickSort алгоритмы.

1. Алгоритм Мергеорта

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

На следующем фрагменте кода Метод делает фактическое расщепление в подчиненные и метод Performent_Merge () объединяет две ранее отсортированные массивы в новый отсортированный массив.

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)

Тестовый случай :

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

Выход:

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

2. Алгоритм Quicksort

Этот алгоритм также использует стратегию Divide и Conquer, но вместо этого использует подход сверху вниз, сначала разделяя массив вокруг A Удар Элемент (здесь мы всегда выбираем последний элемент массива, чтобы быть поворотом).

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

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

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

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)

Здесь Метод делает шаг подхода Divide и Conquer, а Способ разбивает массив вокруг поворота и возвращает положение поворота, вокруг которого мы продолжаем рекурсивно разделить подрасход до и после поворота, пока весь массив не будет отсортирован.

Тестовый случай :

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

Выход:

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

Алгоритм быстрой сортировки

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

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

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

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)

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

Прецедент:

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

Вывод:

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

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', )

Объект массива NumPy

Чтобы объявить объект массива numpy, мы сначала импортируем библиотеку , после чего создаем экземпляр нашего вновь созданного массива с помощью функции library.

Приведенный ниже фрагмент объявляет простой 1-мерный массив numpy:

>>> import numpy as np
>>> a = np.array()
>>> print(a)

Каждый массив имеет следующие атрибуты:

• (количество измерений)
• (размер каждого измерения)
• (общий размер массива)
• (тип данных массива)

Элементы массива NumPy имеют один и тот же тип данных, в отличие от списков Python . В результате мы не можем заставить один массив numpy содержать несколько различных типов данных.

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

# Declare a 2-Dimensional numpy array
b = np.array(, ])
print("b -> ndim:", b.ndim)
print("b -> shape:", b.shape)
print("b -> size:", b.size)
print("b -> dtype:", b.dtype)

Выход:

b -> ndim: 2
b -> shape: (2, 3)
b -> size: 6
b -> dtype: dtype('int64')