Linspace python что делает

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

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

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

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

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

import numpy as np import matplotlib.pyplot as plt y = np.zeros(5) x1 = np.linspace(0, 10, 5) x2 = np.linspace(0, 10, 5) plt.plot(x1, y, 'o') plt.plot(x2, y + 0.5, 'o') plt.ylim([-0.5, 1]) plt.show()

Синтаксис

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

• start -> Начальная точка (включительно) диапазона.
• end -> Конечная точка (в комплекте) диапазона.
• num -> Общее количество точек в последовательности.

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

import numpy as np a = np.linspace(0.02, 2, 10) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a))

Linear Sequence from 0.02 to 2: [0.02 0.24 0.46 0.68 0.9 1.12 1.34 1.56 1.78 2. ] Length: 10

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

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

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

import numpy as np a = np.linspace(0.02, 2, 10, endpoint=False) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a))

Linear Sequence from 0.02 to 2: [0.02 0.218 0.416 0.614 0.812 1.01 1.208 1.406 1.604 1.802] Length: 10

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

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

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

import numpy as np a = np.linspace(0.02, 2, 10, retstep=True) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a))

Linear Sequence from 0.02 to 2: (array([0.02, 0.24, 0.46, 0.68, 0.9 , 1.12, 1.34, 1.56, 1.78, 2. ]), 0.22) Length: 2

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

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

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

По умолчанию (axis = 0) образцы будут располагаться вдоль новой оси, вставленной в начало. Мы можем использовать axis = -1, чтобы получить ось в конце.

import numpy as np p = np.array([[1, 2], [3, 4]]) q = np.array([[5, 6], [7, 8]]) r = np.linspace(p, q, 3, axis=0) print(r) s = np.linspace(p, q, 3, axis=1) print(s)

array([[[1., 2.], [3., 4.]], [[3., 4.], [5., 6.]], [[5., 6.], [7., 8.]]]) array([[[1., 2.], [3., 4.], [5., 6.]], [[3., 4.], [5., 6.], [7., 8.]]])

В первом случае, поскольку 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, которая также генерирует линейную последовательность с одинаковым размером шага.

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

Синтаксис

array = numpy.arange(start, stop, step, dtype=None)

• start -> Начальная точка (включенная) диапазона, которая по умолчанию установлена на 0;
• stop -> Конечная точка (исключенная) диапазона;
• step -> Размер шага последовательности, который по умолчанию равен 1. Это может быть любое действительное число, кроме нуля;
• dtype -> Тип выходного массива. Если dtype не указан (или указан, как None), тип данных будет выведен из типа других входных аргументов.

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

import numpy as np a = np.arange(0.02, 2, 0.1, None) print('Linear Sequence from 0.02 to 2:', a) print('Length:', len(a))

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

Linear Sequence from 0.02 to 2: [0.02 0.12 0.22 0.32 0.42 0.52 0.62 0.72 0.82 0.92 1.02 1.12 1.22 1.32 1.42 1.52 1.62 1.72 1.82 1.92] Length: 20

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

>>> np.arange(0, 10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

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

import numpy as np # Invalid Step Size! a = np.arange(0, 10, 0)

ZeroDivisionError: division by zero

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

Пример

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

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

import numpy as np import matplotlib.pyplot as plt y = np.zeros(5) # Construct two linear sequences # First one has a step size of 4 units x1 = np.arange(0, 20, 4) # Second one has a step size of 2 units x2 = np.arange(0, 10, 2) # Plot (x1, [0, 0, ..]) plt.plot(x1, y, 'o') # Plot (x2, [0.5, 0.5, ..]) plt.plot(x2, y + 0.5, 'o') # Set limit for y on the plot plt.ylim([-0.5, 1]) plt.show()

Как вы можете видеть, оранжевые точки представляют линейную последовательность от 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.

for i in np.arange(100): pass

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

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

import timeit import numpy as np # For smaller arrays print('Array size: 1000') # Time the average among 10000 iterations print('range():', timeit.timeit('for i in range(1000): pass', number=10000)) print('np.arange():', timeit.timeit('np.arange(1000)', number=10000, setup='import numpy as np')) # For large arrays print('Array size: 1000000') # Time the average among 10 iterations print('range():', timeit.timeit('for i in range(1000000): pass', number=10)) print('np.arange():', timeit.timeit('np.arange(1000000)', number=10, setup='import numpy as np'))

Array size: 1000 range(): 0.18827421900095942 np.arange(): 0.015803234000486555 Array size: 1000000 range(): 0.22560399899884942 np.arange(): 0.011916546000065864

Как видите, numpy.arange() особенно хорошо работает для больших последовательностей. Это почти в 20 раз (!!) быстрее обычного кода Python для размера всего 1000000, который будет лучше масштабироваться только для больших массивов.

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

Источник

numpy.linspace#

Return evenly spaced numbers over a specified interval.

Returns num evenly spaced samples, calculated over the interval [start, stop].

The endpoint of the interval can optionally be excluded.

Changed in version 1.16.0: Non-scalar start and stop are now supported.

Changed in version 1.20.0: Values are rounded towards -inf instead of 0 when an integer dtype is specified. The old behavior can still be obtained with np.linspace(start, stop, num).astype(int)

The starting value of the sequence.

stop array_like

The end value of the sequence, unless endpoint is set to False. In that case, the sequence consists of all but the last of num + 1 evenly spaced samples, so that stop is excluded. Note that the step size changes when endpoint is False.

num int, optional

Number of samples to generate. Default is 50. Must be non-negative.

endpoint bool, optional

If True, stop is the last sample. Otherwise, it is not included. Default is True.

retstep bool, optional

If True, return (samples, step), where step is the spacing between samples.

dtype dtype, optional

The type of the output array. If dtype is not given, the data type is inferred from start and stop. The inferred dtype will never be an integer; float is chosen even if the arguments would produce an array of integers.

The axis in the result to store the samples. Relevant only if start or stop are array-like. By default (0), the samples will be along a new axis inserted at the beginning. Use -1 to get an axis at the end.

There are num equally spaced samples in the closed interval [start, stop] or the half-open interval [start, stop) (depending on whether endpoint is True or False).

step float, optional

Only returned if retstep is True

Size of spacing between samples.

Similar to linspace , but uses a step size (instead of the number of samples).

Similar to linspace , but with numbers spaced evenly on a log scale (a geometric progression).

Similar to geomspace , but with the end points specified as logarithms.

>>> np.linspace(2.0, 3.0, num=5) array([2. , 2.25, 2.5 , 2.75, 3. ]) >>> np.linspace(2.0, 3.0, num=5, endpoint=False) array([2. , 2.2, 2.4, 2.6, 2.8]) >>> np.linspace(2.0, 3.0, num=5, retstep=True) (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) 

>>> import matplotlib.pyplot as plt >>> N = 8 >>> y = np.zeros(N) >>> x1 = np.linspace(0, 10, N, endpoint=True) >>> x2 = np.linspace(0, 10, N, endpoint=False) >>> plt.plot(x1, y, 'o') [] >>> plt.plot(x2, y + 0.5, 'o') [] >>> plt.ylim([-0.5, 1]) (-0.5, 1) >>> plt.show() 

Источник