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

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

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

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

Оглавление

* [Понимание функции NumPy linspace()](#ponimanie-funkcii-numpy-linspace)
* [Создание равномерно распределенных диапазонов чисел с помощью NumPy linspace](#sozdanie-ravnomerno-raspredelennykh-diapazonov-chisel-s-pomoshyu-numpy-linspace)
* [Получение размера шага из функции linspace NumPy](#poluchenie-razmera-shaga-iz-funkcii-linspace-numpy)
* [NumPy linspace против функций NumPy arange](#numpy-linspace-protiv-funkcii-numpy-arange)
* [Создание массивов двух или более измерений с помощью NumPy linspace](#sozdanie-massivov-dvukh-ili-bolee-izmerenii-s-pomoshyu-numpy-linspace)
* [Использование linspace NumPy для построения функций](#ispolzovanie-linspace-numpy-dlya-postroeniya-funkcii)
* [Выводы](#vyvody)
* [Дополнительные ресурсы](#dopolnitelnye-resursy)

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

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

```python
# Понимание функции 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        | Описание                                                                                                                            |
| ----------- | ------------------ | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `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 полезна для создания диапазонов равномерно распределенных чисел, без необходимости определять размер шага. Это может быть очень удобно, когда вы хотите иметь определенные начальную и конечную точки, а также заданное количество выборок.

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

```python
# Использование функции 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=`, чтобы настроить количество значений, включенных в наше линейное пространство:

```python
# Настройка количества значений в массиве
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. Если мы хотим изменить это поведение, то мы можем изменить параметр

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

```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 (целые числа):

```python
# Указание типа данных целых чисел в функции 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`, функция вернет кортеж, который включает в себя диапазон значений и размер шага.

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

```python
# Получение шага из функции 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, и также возвращает шаг между этими значениями.

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

```python
# Распаковка массива и шага из 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()` для создания массивов размерностью более одного измерения. Это может быть полезно, когда нам нужно создать данные, основанные более чем на одном измерении.

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

```python
# Создание массива двумерного массива
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].

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

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

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

```python
# Изменение оси в нашем многомерном массиве
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
# Визуализация функции сигмоиды на 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.

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

<figure><img src="https://datagy.io/wp-content/uploads/2022/05/Sigmoid-with-numpy-linspace-Few-Samples.png" alt="Sigmoid with numpy linspace Few Samples" height="480" width="640"><figcaption><p>Сигмовидная функция с меньшим линейным пространством</p></figcaption></figure>

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

```python
# Добавление большего количества значений в массив
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, чтобы получить более гладкий график функции сигмоиды.

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

<figure><img src="https://datagy.io/wp-content/uploads/2022/05/Sigmoid-with-numpy-linspace-More-Samples.png" alt="Sigmoid with numpy linspace More Samples" height="480" width="640"><figcaption><p>Сигмовидная функция с большим линейным пространством</p></figcaption></figure>

## Выводы

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

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

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

* [Пространство журналов NumPy: понимание функции np.logspace()](numpy-logspace-ponimanie-funkcii-np.logspace)
* [NumPy для науки о данных в Python](numpy-dlya-data-science-na-python)
* [Таблица NumPy для упорядочения массивов](ispolzovanie-numpy-tile-dlya-raspolozheniya-massivov)
* [NumPy Zeros: Создание нулевых массивов и матриц в NumPy](numpy-zeros-sozdanie-massivov-i-matric-s-nulyami-v-numpy)
* Numpy нормальное (гауссово) распределение (Numpy Random Normal)
