np arange что это

Python и DataScience: изучаем возможности универсальной библиотеки Numpy

От переводчика: это перевод материала Ракшита Васудева, давно и плотно изучающего DataScience и применение в ней языка Python. Автор рассказывает о мощной библиотеке Numpy, который позволяет реализовать многие возможности машинного обучения и работы с большими данными.

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

Skillbox рекомендует: Практический курс «Python-разработчик с нуля».
Напоминаем: для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».

Импорт библиотеки

В этом месте мы говорим Python, что np — это референс для Numpy, который и будет использоваться впредь.

Теперь создадим массив python и массив np.

Большой разницы при выводе нет.

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

np.arange()

([start],stop,[step]) упорядочивает цифры. Вот что это означает для машины.

Формируем np-список, начиная с 0 до 10, но не включаем 10, плюс увеличиваем цифры на 2 каждый раз.

Таким образом, у нас получается вот что:
array([0, 2, 4, 6, 8])

Важно помнить, что последняя цифра не включается в список.

Этот массив можно также назвать матрицей или вектором. Поэтому не переживайте, когда я говорю, например: «Форма матрицы — 2*3». Все это означает, что наш массив в итоге будет выглядеть примерно так:

Теперь давайте поговорим о таком параметре, как shape для массива np по умолчанию. Shape здесь — атрибут. Пример его использования — ниже.

Это матрица из чисел, где в ряду всего 9 элементов. В принципе, идеальной является матрица 1*9, не так ли?

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

Вот пример использования reshape() на практике.

Обратите внимание, что reshape возвращает многомерную матрицу. На это указывают две квадратных скобки в начале. [[1, 2, 3, 4, 5, 6, 7, 8, 9]] является потенциально многомерной матрицей в отличие от [1, 2, 3, 4, 5, 6, 7, 8, 9].

Если взять параметр shape для B, то им будет (3,3):

Перейдем к np.zeros()

Что прописано в этом коде?

Именно: здесь задана матрица формата 3*4, заполненная нулями. Вот вывод:

np.zeros((n,m)) возвращает матрицу формата n*m, заполненную нулями. Все просто.

А что делает np.eye()?

Возвращает нам единичную матрицу с определенными характеристиками.

Как умножить две матрицы?

Нет проблем: для этого используется np.dot(), Эта функция — скалярное произведение, если в нее передали вектора и произведение матриц (самое обыкновенное).

Пример: A = (2,3) & B = (3,2). Здесь число столбцов в А — 3. Число строк в В — 3. Поскольку характеристики совпадают, умножение возможно.

Мы подготовили матрицы к умножению. Далее — действуем.

А теперь давайте добавим отдельные элементы в матрицу

np.sum() добавляет элементы в матрицу.

Однако у нас есть два варианта.

1. Складываем по строкам

6 — сумма первой строки (1, 2, 3).
15 — второй (4, 5, 6).
24 — третьей (7, 8, 9).

2. Складываем по столбцам

12 — сумма по первому столбцу (1, 4, 7).
15 — по второму (2, 5, 7).
18 — по третьему (3, 6, 9).

Ниже — видео, созданное автором, где все, что описано выше, объясняется еще раз, более наглядно.

Источник

Функции numpy.linspace() и numpy.arange() в Python

Функция numpy.linspace() в Python используется для генерации последовательности чисел в линейном пространстве с одинаковым размером шага.

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

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

Например, следующий код отображает 2 линейные последовательности от 0 до 10 с использованием numpy.linspace(), чтобы показать, что последовательность генерирует единообразие.

Синтаксис

Формат: array = numpy.linspace (start, end, num = num_points) будет генерировать единообразную последовательность между началом и концом с общим количеством элементов num_points.

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

Приведенный выше фрагмент генерирует однородную последовательность от 0,02 до 2, состоящую из 10 элементов.

Аргумент ключевого слова конечной точки

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

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

Аргумент ключевого слова retstep

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

Поскольку на выходе получается кортеж, его длина равна 2, а не 10!

Аргумент ключевого слова axis

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

В первом случае, поскольку axis = 0, мы берем пределы последовательности от первой оси.

Здесь пределы – это пары подмассивов [1, 2] и [5,6], а также [3, 4] и [7,8], берущие элементы из первой оси p и q. Теперь мы сравниваем соответствующие элементы из полученной пары, чтобы сгенерировать последовательности.

Таким образом, последовательности [[от 1 до 5], [от 2 до 6]] для первой строки и [[от 3 до 7]], [от 4 до 8]] для второй пары (строки), которая оценивается и объединяется для формирования [[[1, 2], [3, 4]], [[3, 4], [5, 6]], [[5, 6], [7,8]]],

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

Последовательности с [1, 2] по [5, 7] и [3, 4] по [7, 8] рассматриваются и вставляются в столбцы результата, в результате чего получается [[[1, 2], [3, 4 ], [5, 6]], [[3, 4], [5, 6], [7, 8]]].

Будучи генератором линейной последовательности, функция numpy.arange() в Python используется для генерации последовательности чисел в линейном пространстве с равномерным размером шага.

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

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

Синтаксис

Давайте рассмотрим простой пример, чтобы понять это:

Это сгенерирует линейную последовательность от 0,2 (включительно) до 2 (исключено) с размером шага 0,1, поэтому в последовательности будет (2 — 0,2) / 0,1 — 1 = 20 элементов, что является длиной результирующего массив numpy.

Вот еще одна строка кода, которая генерирует числа от 0 до 9 с помощью arange(), используя размер шага по умолчанию 1:

Если размер шага равен 0, это недопустимая последовательность, поскольку шаг 0 означает, что вы делите диапазон на 0, что вызовет исключение ZeroDivisionError Exception.

ПРИМЕЧАНИЕ. Эта функция немного отличается от numpy.linspace(), которая по умолчанию включает как начальную, так и конечную точки для вычисления последовательности. Он также не принимает в качестве аргумента размер шага, а принимает только количество элементов в последовательности.

Пример

Давайте теперь объединим все это в простой пример, чтобы продемонстрировать линейность последовательностей, генерируемых numpy.arange().

Следующий код отображает 2 линейные последовательности между [0, 20] и [0, 10] с помощью numpy.arange(), чтобы показать, что последовательность генерирует единообразие, поэтому результирующие массивы являются линейными.

Как вы можете видеть, оранжевые точки представляют линейную последовательность от 0 до 10 с размером шага 2 единицы, но поскольку 10 не включено, последовательность равна [0, 2, 4, 6, 8]. Точно так же синие точки представляют последовательность [0, 4, 8, 12, 16].

Сравнение numpy.arange() и range()

Весь смысл использования модуля numpy состоит в том, чтобы гарантировать, что выполняемые нами операции выполняются как можно быстрее, поскольку numpy – это интерфейс Python для кода C ++ нижнего уровня.

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

Следовательно, numpy.arange() намного быстрее, чем собственная функция range() для генерации аналогичных линейных последовательностей.

Тест производительности

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

Например, в приведенном ниже фрагменте показано, как не следует использовать numpy.

Рекомендуемый способ – напрямую использовать операцию numpy.

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

Источник

Метод NumPy arange() в Python

В этом уроке мы обсудим метод Numpy arange() в Python. NumPy-очень популярный модуль в Python, в основном используемый пользователями для его более быстрого

Вступление

Основы метода Numpy arange()

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

Пример Numpy arange()

Давайте разберемся в работе метода Numpy arange() на примере:

Вывод :

Использование Numpy arange() в Python

Метод arrange() принимает четыре аргумента start, stop, step и тип, как мы видели в предыдущем разделе. Теперь мы посмотрим, как мы можем использовать этот метод различными способами и как он работает для всех случаев.

1. Использование функции arrange() с одним аргументом

2. Использование Numpy arange() без шага

Вывод :

Итак, здесь мы ясно видим, что, хотя мы не передали параметр step, созданный массив состоит из значений [5 6 7]. То есть, в данном случае, значение по умолчанию 1 был использован для генерации соответствующего вывода.

3. Использование функции arrange() с отрицательными параметрами

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

Вывод :

4. Использование Numpy arange() с циклами Python

Вывод :

В приведенном выше коде,

Несмотря на то, что мы использовали метод arrange() с собственным циклом for в Python, это влияет на скорость выполнения и производительность кода. Он также становится медленным.

Numpy arange() Vs range() в Python

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

Вывод

Источник

NumPy в Python. Часть 2

Продолжаем перевод статьи о numpy в python. Для тех кто не читал первую часть, сюда: Часть 1. А всем остальным — приятного чтения.

Функция arange аналогична функции range, но возвращает массив:

Функции zeros и ones создают новые массивы с установленной размерностью, заполненные этими значениями. Это, наверное, самые простые в использовании функции для создания массивов:

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

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

Функция eye возвращает матрицу с единичками на к-атой диагонали:

Математические операции над массивами

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

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

При несоответствии в размере выбрасываются ошибки:

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

Тут, одномерный массив b был преобразован в двухмерный, который соответствует размеру массива a. По существу, b был повторен несколько раз, для каждой «строки» a. Иначе его можно представить так:

Python автоматически преобразовывает массивы в этом случае. Иногда, однако, когда преобразование играет роль, мы можем использовать константу newaxis, чтобы изменить преобразование:

Вдобавок к стандартным операторам, в numpy включена библиотека стандартных математических функций, которые могут быть применены поэлементно к массивам. Собственно функции: abs, sign, sqrt, log, log10, exp, sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh, и arctanh.

Функции floor, ceil и rint возвращают нижние, верхние или ближайшие (округлённое) значение:

Также в numpy включены две важные математические константы:

Перебор элементов массива

Проводить итерацию массивов можно аналогично спискам:

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

Множественное присваивание также доступно при итерации:

Базовые операции над массивами

Для получения каких-либо свойств массивов существует много функций. Элементы могут быть суммированы или перемножены:

В этом примере были использованы функции массива. Также можно использовать собственные функции numpy:

Для большинства случаев могут использоваться оба варианта.
Некие функции дают возможность оперировать статистическими данными. Это функции mean (среднее арифметическое), вариация и девиация:

Можно найти минимум и максимум в массиве:

Функции argmin и argmax возвращают индекс минимального или максимального элемента:

Для многомерных массивов каждая из функций может принять дополнительный аргумент axis и в зависимости от его значения выполнять функции по определенной оси, помещая результаты исполнения в массив:

Как и списки, массивы можно отсортировать:

Значения в массиве могут быть «сокращены», чтобы принадлежать заданному диапазону. Это тоже самое что применять min(max(x, minval), maxval) к каждому элементу x:

Уникальные элементы могут быть извлечены вот так:

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

Вот и вторая статья подошла к концу. Спасибо за уделенное внимание и удачи в ваших начинаниях! До скорой встречи.

Источник

Python – numpy.arange ()

Будучи линейной последовательностью генератора, функция Numpy.Arange () используется для генерации последовательности чисел в линейном пространстве с равномерным размером шага. Это

Будучи линейной последовательностью генератора, numpy.arange () Функция используется для генерации последовательности чисел в линейном пространстве с равномерным размером шага.

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

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

Синтаксис

Давайте возьмем простой пример, чтобы понять это:

Это будет генерировать линейную последовательность от 0.2 (включая) до 2 (исключен) с шагом размером 0,1 Так что будет (2 – 0,2)/0,1 – 1 = 20 Элементы в последовательности, которая представляет собой длину результирующего наменяющего массива.

Вот еще одна строка кода, которая генерирует количество от 0 до 9, используя Arange () Используя размер шага по умолчанию 1:

Если размер шага предоставляется как 0, это не является допустимой последовательностью, поскольку шаг 0 подразумевает, что вы разделяете диапазон на 0, что поднимет | ZerodivisionError Исключение.

Простой пример

Давайте теперь поставим все это вместе в простой пример, чтобы продемонстрировать линейность последовательностей, генерируемых numpy.arange () Отказ

Следующие кодовые участки 2 линейных последовательностей между [0, 20] и [0, 10] Использование numpy.arange () Чтобы показать, что существует однородность, генерируемая последовательностью, поэтому полученные массивы являются линейными.

Как видите, оранжевые точки представляют линейную последовательность от 0 до 10, имеющих размер шага 2 единицы, но с 10 не включен, последовательность – [0, 2, 4, 6, 8] Отказ Точно так же синие точки представляют последовательность [0, 4, 8, 12, 16] Отказ

Numpy.Arange () VS Range ()

Весь смысл использования numpy Модуль – убедиться, что операции, которые мы выполняем, выполняются как можно быстрее, поскольку numpy это интерфейс Python для более низкого уровня C ++.

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

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

Тест производительности

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

Например, приведенный ниже фрагмент показывает, как вы должны Не Используйте Numpy.

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

Давайте проверим разницу в производительности, используя Python’s Время течения модуль.

Поэтому numpy.arange () должен быть единодушный выбор среди программистов при работе с большим массивом.

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

Источник