np.arange: как использовать функцию numpy arange () в Python

Создание массивов NumPy необходимо, когда вы работаете с другими библиотеками Python, которые полагаются на них, такими как SciPy, Pandas, scikit-learn, Matplotlib и другими. NumPy — идеальная библиотека для создания массивов и работы с ними, поскольку она позволяет повысить производительность, позволяет писать краткий код и предлагает полезные процедуры.

Numpy имеет самый важный массив, называемый ndarray. NumPy предлагает множество процедур создания массивов для разных обстоятельств. Arange () — одна из таких функций, основанная на числовых диапазонах. Его часто называют np.arange, потому что np — это широко используемое сокращение от NumPy. Давайте подробно обсудим эту функцию.

np.arange

Метод np.arange () возвращает ndarray , содержащий равномерно распределенные значения в заданном диапазоне. Функция numpy arange () принимает четыре параметра, включая start, stop, step, и dtype , и возвращает равномерно распределенные значения в заданном интервале.

Numpy arange () — одна из функций создания массива на основе числовых диапазонов. Он создает экземпляр ndarray с равномерно распределенными значениями и возвращает ссылку на него.

Для целочисленных аргументов метод эквивалентен встроенной функции диапазона Python, но возвращает ndarray, а не список.

Синтаксис

Синтаксис

Функция strong> numpy.arange () следующая.

 numpy.arange (start,  stop, step, dtype) 

Параметры

Это следующие параметры.

start : число, необязательно. Начало интервала. Интервал включает это значение. Начальное значение по умолчанию — 0.

stop : number. Конец интервала. Интервал не содержит значения остановки, за исключением случаев, когда step не является целым числом, а округление с плавающей запятой влияет на длину out .

step

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

dtype : тип выходного массива. Если dtype не указан, выведите тип данных из других входных аргументов. Если dtype опущен, arange () попытается вывести элементы массива из типов start, stop и step.

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

Возвращает массив. Вы можете найти более подробную информацию о параметрах и возвращаемом значении функции arange () в официальной документации.

Пример np arange

Давайте посмотрим на пример функции NumPy arange в Jupyter Notebook.

При работе с подпрограммами NumPy вы должны сначала импортировать Numpy.

Напишите следующий код внутри первая ячейка.

 import numpy as np 

Теперь у вас есть импортированный NumPy, и вы готовы применить arange () .

Запустите эту ячейку, используя Ctrl + Enter, а затем напишите следующий код в следующей ячейке.

 npdata = np.arange (3) npdata 

См. вывод ниже.

Он создал массив numpy от 0 до 2 элементов длиной 3.

Давайте посмотрим на другой пример. Напишите в ячейке следующий код Python.

 npdata = np.arange (40) npdata.shape = (5, 8) npdata 

В приведенном выше коде мы определили массив с элементами 40, а затем у нас есть атрибут shape массива numpy, чтобы сформировать этот массив в 5 строк и 8 столбцов. См. Результат.

Начните и Параметры остановки установлены в numpy arange

Давайте определим параметры запуска и остановки в функции numpy arange. См. Вывод.

 npdata = np.arange (1,21,3) npdata 

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

Приведенный выше пример кода возвращает массив с массивом от 1 до 21 с шагом 3. Итак, 1, (1 +3 = 4), (4 + 3 = 7),… до 21 в качестве конечной точки.

Теперь давайте посмотрим на другой пример.

 # app.pyimport numpy as npprint (np.arange (1, 21.1, 3)) 

См. результат.

 ➜ pyt python3 app.py [1. 4. 7. 10. 13. 16. 19.] ➜ pyt 

В в этом случае вы получите массив из семи элементов.

Обратите внимание, что в этом примере создается массив чисел с плавающей запятой, в отличие от предыдущего. Это потому, что вы не определили dtype, а arange () вывел его за вас.

Предоставление всех аргументов позиционного диапазона

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

 import numpy as npdata = np.arange (start = 2, stop = 12, step = 3) print (data  ) 

Вывод

 [2 5 8 11] 

В этом примере начало равно 2. Следовательно, первый элемент полученного массива равен 2. Шаг равен 3, поэтому ваше второе значение — 2 + 3, то есть 5, а третье значение в массиве — 5 + 3, что равно 8. , а окончательное значение 8 + 3 = 11.

Теперь вы можете передать start , stop и step также в качестве позиционных аргументов.

 import numpy as npdata = np.arange (2, 12, 3) print (data) 

Вывод

 [2 5 8 11] 

Приведенный выше пример кода эквивалентен предыдущему, но более краток.

Предоставление аргументов с плавающей запятой

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

 импортировать numpy как npdata = np.arange (2, 11.1, 3) print (data) 

Вывод

 [2. 5. 8. 11.] 

В этом случае вы получите массив с четырьмя элементами, которые включают 11.

Примечание. что в этом примере создается массив чисел с плавающей запятой, в отличие от предыдущего. Это потому, что вы не определили dtype, а arange () вывел его за вас.

Предоставление двух аргументов диапазона

Вы можете опустите параметр шага. В следующем случае arange () использует значение по умолчанию, равное 1. Следующие два оператора эквивалентны.

 import numpy as npdata = np.arange (2, 5) print (data) 

Вывод

 [2 3 4] 

Использование метода np.arange () с приращением 1 — распространенный случай на практике. Опять же, вы можете написать предыдущий пример более точно с позиционными аргументами start и stop.

Обеспечение одного аргумента диапазона

Функция numpy arange () для правильной работы принимает хотя бы один аргумент. Чтобы быть более кратким, вы должны обеспечить начало. Но что произойдет, если вы не остановитесь? Как np.arange () знает, когда прекратить подсчет?

В этом случае массив начинается с 0 и заканчивается до достижения начального значения! Опять же, значение шага по умолчанию равно 1. Другими словами, arange () предполагает, что вы указали остановку (вместо start), и что start равен 0, а step равен 1.

  импортировать numpy как npdata = np.arange (5) print (data) 

Вывод

 [0 1 2 3 4]  

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

TypeError в arange ()

Если вы попытаетесь явно укажите остановку без запуска, тогда вы получите TypeError .

 import numpy as npdata = np.arange (stop = 5) print (data)  

 Отслеживание (последний вызов последним): файл «app.py», строка 3, в   data = np.arange (stop = 5) TypeError: arange () отсутствует обязательный аргумент 'start' (pos 1) 

Вы получили TypeError, потому что arange () не позволяет избежать первый аргумент, который явно соответствует началу. Если вы предоставите единственный аргумент, он должен начаться, но arange () будет использовать его, чтобы определить, где заканчивается подсчет. Если вы явно укажете остановку без запуска, вы получите эту ошибку с сообщением TypeError: arange () пропущен обязательный аргумент ‘start’ (pos 1).

Передача отрицательных аргументов

Если вы укажете отрицательные значения для start или для обоих start и stop и иметь положительный step , тогда arange () будет работать так же, как и со всеми положительными аргументами:

 # app.pyimport numpy as npprint (np. arange (-8, -2, 2)) 

См. вывод.

 ➜ pyt python3 app.py [-8-6-4] ➜ pyt 

Подсчет начинается со значения start , многократно увеличиваясь на step и заканчивая перед stop достигнут.

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

Обратный отсчет

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

 import numpy as npdata = np.arange (4, 1, -2) print  (данные) 

Вывод

 [4 2] 

В приведенном выше коде start равно 4, и результирующий массив начинается с этого значения. Шаг равен -2, поэтому второе значение равно 4 + (- 2), то есть 2. Теперь отсчет останавливается здесь, так как стоп (0) достигается до следующего значения (-2). Итак, на выходе мы получаем [4, 2].

В этих сценариях начало больше, чем остановка, и оно отрицательное, и вы ведете обратный отсчет.

Работа с пустыми массивами

Есть несколько крайних случаев, когда вы можете получить пустые массивы NumPy с помощью arange (). Это обычные экземпляры numpy — ndarray без каких-либо элементов.

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

  # app.pyimport numpy as npprint (np.arange (11, 11)) 

См. вывод.

 ➜ pyt python3 app.py [] ➜ pyt 

Функция Numpy arange reshape ()

numpy.reshape (array, shape, order = ‘C’ )

Он формирует массив без изменения данных массива.

 # app.pyimport numpy as np arr = np.arange (8)  print ("Исходный массив:  n", arr) # форма arr с 2 строками и 4 столбцами arr = np.arange (8) .reshape (2, 4) print (" nМассив изменен с 2 строками и 4 столбцами:   n ", arr) # форма arr с 2 строками и 4 столбцами arr = np.arange (8) .reshape (4, 2) print ("  nArray изменена с 2 строками и 4 столбцами:  n ", arr) # Создает  3D arr arr = np.arange (8) .reshape (2, 2, 2) print (" nОригинальный массив преобразован в 3D:  n", arr) 

См. Результат.

 ➜ pyt python3 app.pyO  изначальный Массив: [0 1 2 3 4 5 6 7] Массив изменен с 2 строками и 4 столбцами: [[0 1 2 3] [4 5 6 7]] Массив преобразован с 2 строками и 4 столбцами: [[0 1]  [2 3] [4 5] [6 7]] Исходный массив преобразован в 3D: [[[0 1] [2 3]] [[4 5] [6 7]]] ➜ pyt 

Numpy Datatypes

1. Все элементы в массиве NumPy имеют один и тот же тип, называемый dtype ( тип данных ).
2. Numpy dtypes допускают большее растирание, чем встроенные числовые типы Python.
3. Некоторые подпрограммы Numpy могут принимать Python числовые типы и наоборот.
4. Некоторые типы данных Numpy имеют определения, зависящие от платформы.
5. В некоторых случаях псевдонимы типов Numpy совпадают с именами встроенных типов Python.

См. следующий код.

 import numpy as npdata = np.arange (4, 1, -2) print (data.dtype) 

Вывод

 int64 

Функция arange () попытается вывести dtype полученного массива. Это зависит от типов start , stop и step .

Здесь , массив, созданный функцией np arange (), равен [4, 2]. Вот почему dtype данных массива будет одним из целочисленных типов, обслуживаемых Numpy.

В этом случае Numpy по умолчанию выбирает dtype int64. Это 64-битный (8-байтовый) целочисленный тип.

Параметр dtype = int не относится к Python int. Он переводится в NumPy int64 или просто np.int. Итак, на выходе мы получили int64, что не то же самое, что Python int. Это 64-битный целочисленный тип.

Определить тип данных при создании массива

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

 import numpy as npdata = np.arange (5, dtype = float) print (data) print (data.dtype)  

 [0.  1. 2. 3. 4.] float64 

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

Аргумент dtype = float не относится к Python float. Он переводится как NumPy float64 или просто np.float. Итак, на выходе мы получили float64, что не то же самое, что Python float. Это 64-битный тип с плавающей запятой.

Numpy предоставляет нам несколько целочисленных типов данных фиксированного размера, которые отличаются объемом памяти и ограничениями:

1. np.int8 : это 8-битовое целое число со знаком (от -128 до 127).
2. np.uint8 : это 8-разрядное целое число без знака (от 0 до 255)
3. np.int16 : это 16-разрядное целое число со знаком (от -32768 до 32767)
4. : это 16-битовое целое число без знака (от 0 до 65535).
5. np .int32 : это 32-битное целое число со знаком (от -2 ** 31 до 2 ** 31-1).
6. np.uint32 : Это 32-битное целое число без знака (от 0 до 2 ** 32-1).
7. np.int64 : это 64-битное подписанное целое число (от -2 ** 63 до 2 ** 63-1)
8. np.uint64 : это 64-битное целое число без знака (от 0 до 2 ** 64-1)

Если вам нужны другие целочисленные типы для элементов вашего массива, тогда вам нужно указать dtype.

  импортировать numpy как npdata =  np.arange (5, dtype = np.float32) print ('Данные:', data) print ('Тип данных:', data.dtype) print ('Размер в байтах:', data.itemsize) 

Вывод

 Данные: [0.  1. 2. 3. 4.] Тип данных: float32 Размер в байтах: 4 

Numpy arange vs. диапазон Python

Для больших массивов np.arange () должен быть более быстрым решением.

Range () дает вам обычный список (python 2) или специализированный «объект диапазона» (например, генератор; python 3), np .arange дает вам массив numpy. Если вы заботитесь о скорости достаточно, чтобы использовать numpy, используйте массивы numpy.

Массивы NumPy более компактны, чем списки Python: список списков, как вы описываете, в Python займет не менее 20 МБ или Итак, в то время как трехмерный массив NumPy с плавающими точками одинарной точности в ячейках уместился бы в 4 МБ. Доступ к чтению и записи элементов также быстрее с NumPy.

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

Наконец, пример Numpy arange окончен.

См. Также

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

Python Pandas DataFrame

Pandas DataFrame read_csv ()

Python Pandas Series

Свойство Python ()