NumPy linspace: создание равномерно расположенных массивов с помощью np.linspace

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

К концу данного руководства вы узнаете:

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

Оглавление

Понимание функции NumPy linspace()

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

# Понимание функции np.linspace()
import numpy as np

np.linspace(
    start,  # Начальное значение последовательности
    stop,   # Конечное значение последовательности
    num=50,  # Количество точек для генерации
    endpoint=True,  # True, если последнее значение включено, иначе False
    retstep=False,  # True, чтобы вернуть шаг между значениями
    dtype=None,    # Тип данных возвращаемого массива
    axis=0         # Ось, вдоль которой генерируются значения
)

Таблица ниже детализирует параметры функции linspace() в NumPy, а также их значения по умолчанию и ожидаемые значения

Параметр Знач. по умолчанию Data Type Описание

Параметр	Знач. по умолчанию	Data Type	Описание
`start=`	N/A	Integer or array	Начальное значение последовательности
`stop=`	N/A	Integer or array	Конечное значение последовательности, если для параметра `endpoint=` не установлено значение `False.`
`num=`	`50`	Integer	Количество сэмплов, которые нужно сгенерировать. Должно быть неотрицательным.
`endpoint=`	`True`	Boolean	Использовать ли остановку в качестве последней выборки
`retstep=`	`False`	Boolean	Если `True,` возвращает кортеж (выборки, шаг), где шагом является расстояние между выборками.
`dtype=`	`None`	dtype	Тип данных выходного массива. Если `None`, тип будет выведен и никогда не будет целым числом.
`axis=`	`0`	Integer	Актуально только в том случае, если параметры start и stop аналогичны массиву. Результаты на оси результатов для хранения образцов.

start=

N/A

Integer or array

Начальное значение последовательности

stop=

N/A

Integer or array

Конечное значение последовательности, если для параметра endpoint= не установлено значение False.

num=

50

Integer

Количество сэмплов, которые нужно сгенерировать. Должно быть неотрицательным.

endpoint=

True

Boolean

Использовать ли остановку в качестве последней выборки

retstep=

False

Boolean

Если True, возвращает кортеж (выборки, шаг), где шагом является расстояние между выборками.

dtype=

None

dtype

Тип данных выходного массива. Если None, тип будет выведен и никогда не будет целым числом.

axis=

0

Integer

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

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

Создание равномерно распределенных диапазонов чисел с помощью NumPy linspace

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

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

# Использование функции np.linspace() из библиотеки NumPy
import numpy as np

values = np.linspace(1, 50)
print(values)

# Returns:
# [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.
#  19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36.
#  37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50.]

Из приведенного выше блока кода видно, что когда мы передаем значения start=1 и end=50, возвращаются значения от 1 до 50. По умолчанию функция np.linspace() возвращает массив из 50 значений.

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

Настройка размера шага в NumPy linspace

Давайте посмотрим, как мы можем использовать параметр num=, чтобы настроить количество значений, включенных в наше линейное пространство:

# Настройка количества значений в массиве
import numpy as np

values = np.linspace(1, 50, num=10)
print(values)

# Returns:
# [ 1.          6.44444444 11.88888889 17.33333333 22.77777778 28.22222222
#  33.66666667 39.11111111 44.55555556 50.        ]

Мы видим, что этот массив возвращает 10 значений, варьирующихся от 0 до 50, которые равномерно распределены. Преимущество функции linspace() становится очевидным здесь: нам не нужно определять и понимать размер шага перед созданием нашего массива.

Настройка конечной точки в NumPy linspace

По умолчанию NumPy будет включать указанное значение stop в функцию. Это поведение отличается от многих других функций Python, включая функцию range() Python. Если мы хотим изменить это поведение, то мы можем изменить параметр

Давайте посмотрим, как это работает:

# Изменение поведения конечной точки функции np.linspace()
import numpy as np

values = np.linspace(1, 50, endpoint=False)
print(values)

# Returns:
# [ 1.    1.98  2.96  3.94  4.92  5.9   6.88  7.86  8.84  9.82 10.8  11.78
#  12.76 13.74 14.72 15.7  16.68 17.66 18.64 19.62 20.6  21.58 22.56 23.54
#  24.52 25.5  26.48 27.46 28.44 29.42 30.4  31.38 32.36 33.34 34.32 35.3
#  36.28 37.26 38.24 39.22 40.2  41.18 42.16 43.14 44.12 45.1  46.08 47.06
#  48.04 49.02]

Этот код создает массив, содержащий равномерно распределенные значения в интервале от 1 (включительно) до 50 (исключительно), потому что параметр endpoint установлен на False.

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

Настройка Типа Данных в NumPy Linspace

По умолчанию NumPy будет выводить тип данных, который требуется. Это происходит, когда параметр dtype= использует свой аргумент по умолчанию None. Как мы видели в нашем предыдущем примере, даже когда возвращаемые числа являются равномерно распределенными целыми числами, NumPy никогда не будет выводить тип данных как целое число.

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

# Указание типа данных целых чисел в функции np.linspace() из библиотеки NumPy
import numpy as np

values = np.linspace(1, 50, dtype='int')
print(values)

# Returns:
# [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
#  25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
#  49 50]

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

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

Получение размера шага из функции linspace NumPy

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

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

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

# Получение шага из функции np.linspace() из библиотеки NumPy
import numpy as np

values = np.linspace(1, 10, num=15, retstep=True)
print(values)

# Returns:
# (array([ 1.        ,  1.64285714,  2.28571429,  2.92857143,  3.57142857,
#         4.21428571,  4.85714286,  5.5       ,  6.14285714,  6.78571429,
#         7.42857143,  8.07142857,  8.71428571,  9.35714286, 10.        ]), 0.6428571428571429)

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

Мы можем извлечь значения и размер шага, непосредственно распаковывая кортеж при объявлении переменных:

# Распаковка массива и шага из np.linspace() из библиотеки NumPy
import numpy as np

values, step_size = np.linspace(1, 10, num=15, retstep=True)
print(step_size)

# Returns: 0.6428571428571429

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

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

В следующем разделе вы узнаете, как функция np.linspace() сравнивается с функцией

NumPy linspace против функций NumPy arange

Хотя функции np.linspace() и np.arange() обе возвращают диапазон значений, их поведение сильно отличается:

Функция np.linspace() возвращает диапазон равномерно распределенных значений с заданными началом, концом и количеством значений. В данном случае размер шага зависит от других параметров функции.
Функция np.arange() возвращает ряд равномерно распределенных значений с заданными началом, концом и размером шага. В данном случае количество значений зависит от других параметров функции.

На основе этого анализа можно увидеть, что, хотя функции и очень похожи, у них есть свои конкретные различия. Функция np.linspace() определяет количество значений, в то время как функция np.arange() определяет размер шага.

Создание массивов двух или более измерений с помощью NumPy linspace

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

Давайте рассмотрим пример, а затем как это работает:

# Создание массива двумерного массива
import numpy as np

values = np.linspace([0, 10], [10, 100], num=5)
print(values)

# Returns: 
# [[  0.   10. ]
#  [  2.5  32.5]
#  [  5.   55. ]
#  [  7.5  77.5]
#  [ 10.  100. ]]

Этот код создает двумерный массив, содержащий 5 равномерно распределенных значений в каждом из двух измерений, от [0, 10] до [10, 100].

Давайте разберем, что мы здесь сделали:

Мы определили начальные точки как [0,10], что означает, что два массива будут начинаться со значения 0 и 10 соответственно.
Мы затем определили конечные точки [10, 100], что означает, что массивы будут завершаться на 10 и 100, соответственно.
Оба эти массива содержат по пять чисел и должны быть одинаковой длины.

Мы также можем изменить ось результирующих массивов. Это может быть полезно в зависимости от того, как вы хотите сгенерировать свои данные. Давайте рассмотрим:

# Изменение оси в нашем многомерном массиве
import numpy as np

values = np.linspace([0, 10], [10, 100], num=5, axis=1)
print(values)

# Returns: 
# [[  0.    2.5   5.    7.5  10. ]
#  [ 10.   32.5  55.   77.5 100. ]]

Этот код создает двумерный массив, содержащий 5 равномерно распределенных значений в каждом из двух измерений, от [0, 10] до [10, 100], при этом ось, по которой распределены значения, задана как ось 1 (столбцы).

В приведенном выше примере, мы транспонировали массив, сопоставив его по первой оси.

Использование linspace NumPy для построения функций

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

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

# Визуализация функции сигмоиды на Python
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-100, 100)
y = 1.0 / (1.0 + np.exp(-x))

plt.plot(x, y)
plt.show()

Этот код визуализирует график функции сигмоиды, которая принимает значения от 0 до 1 в зависимости от входных данных x, которые изменяются от -100 до 100.

Это возвращает следующую визуализацию:

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

# Добавление большего количества значений в массив
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-100, 100, num=200)
y = 1.0 / (1.0 + np.exp(-x))

plt.plot(x, y)
plt.show()

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

Это приводит к следующему сглаженному изображению:

Выводы

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

Дополнительные ресурсы

Чтобы узнать больше о смежных темах, ознакомьтесь с нижеприведенными учебными пособиями:

Пространство журналов NumPy: понимание функции np.logspace()
NumPy для науки о данных в Python
Таблица NumPy для упорядочения массивов
NumPy Zeros: Создание нулевых массивов и матриц в NumPy
Numpy нормальное (гауссово) распределение (Numpy Random Normal)

PreviousNumPy where: Условная обработка элементов массива NextКак рассчитать векторное произведение в Python

Last updated 5 months ago