Този урок ще ви научи как да използвате NumPy linspace(), за да създадете масив от равномерно разположени числа в Python.
Ще научите синтаксиса на NumPy linspace(), последван от примери, които ще ви помогнат да разберете как да го използвате.
Забележка: За да следвате този урок, трябва да имате инсталирани Python и NumPy.
Все още нямате NumPy? Съставихме кратко ръководство за инсталиране за вас.
Да започваме!
Съдържание
Инсталирайте и импортирайте NumPy
Преди да започнем урока, нека бързо преминем през стъпките за инсталиране на библиотеката NumPy.
⏩ Ако вече имате инсталиран NumPy, не се колебайте да преминете към следващия раздел.
- Ако използвате Google Colab—базирана в облака среда за преносим компютър Jupyter, можете да импортирате NumPy и да започнете да кодирате веднага. (препоръчва се за този урок ✅)
- Ако искате да настроите локална работна среда, препоръчвам да инсталирате дистрибуцията Anaconda на Python. Anaconda идва с предварително инсталирани няколко полезни пакета. Можете да изтеглите инсталатора за вашата операционна система. Процесът на настройка отнема само няколко минути.⌛
- Ако вече имате инсталиран Python на вашия компютър, пак можете да инсталирате дистрибуцията на Anaconda. Можете да използвате conda или pip за инсталиране и управление на пакети. Можете да изпълните една от следните команди от командния ред на Anaconda, за да инсталирате NumPy.
# Install NumPy using conda conda install numpy # Install NumPy using pip pip install numpy
Като следваща стъпка импортирайте numpy под псевдонима np, като изпълните следната команда. Това ще ви помогне да посочите NumPy като np – без да се налага да въвеждате надолу numpy всеки път, когато имате достъп до елемент в модула.
import numpy as np
Занапред ще използваме нотацията с точка за достъп до всички функции в библиотеката NumPy по следния начин: np.<име-на-функция>.
Случаят с равномерно разположените числа
Когато работите с масиви NumPy, има моменти, в които ще трябва да създадете масив от равномерно разположени числа в интервал.
Преди да продължим, нека бързо да прегледаме друга подобна функция np.arange().
NumPy linspace() срещу NumPy arange()
Ако сте използвали NumPy преди, вероятно сте използвали np.arange(), за да създадете масив от числа в определен диапазон.
Знаете, че np.arange(start, stop, step) връща масив от числа от начало до, но без да включва стоп, в стъпки от стъпка; размерът на стъпката по подразбиране е 1.
Стойността на стъпката обаче не винаги може да е очевидна. Нека видим защо това е така.
Например, ако имате нужда от 4 равномерно разпределени числа между 0 и 1, знаете, че размерът на стъпката трябва да бъде 0,25. Но ако използвате np.arange(), той не включва стойността на спиране от 1. Така че ще трябва да изберете интервал, който надхвърля стойността на спиране.
Следното изображение илюстрира още няколко примера, при които имате нужда от конкретен брой равномерно разположени точки в интервала [a, b].
Равномерно разположени точки в интервал
Първият ни пример за 4 равномерно разположени точки [0,1] беше достатъчно лесно. Знаете, че стъпката между точките трябва да бъде 0,25.
Да предположим, че имате малко по-сложен пример — където трябва да изброите 7 равномерно разположени точки между 1 и 33. Тук размерът на стъпката може да не е много ясен веднага. Можете обаче ръчно да изчислите стойността на стъпката в този случай.
Въпреки това, np.linspace() е тук, за да го направи още по-просто за вас! 😄
Използвайте NumPy linspace
Когато използвате np.linspace(), трябва само да посочите броя на точките в интервала, без да се притеснявате за размера на стъпката. И ще получите обратно масива, както желаете.
С тази мотивация, нека продължим да изучаваме синтаксиса на NumPy linspace() в следващия раздел.
Синтаксис на NumPy linspace()
Синтаксисът за използване на NumPy linspace() е показан по-долу:
np.linspace(start, stop, num, endpoint, retstep, dtype, axis)
В началото горният синтаксис може да изглежда много сложен с много параметри.
Повечето от тях обаче са незадължителни параметри и ще стигнем до много по-прост синтаксис само за няколко минути.
Сега нека започнем с анализ на горния синтаксис:
- start и stop са съответно началната и крайната точка на интервала. И стартът, и стопът могат да бъдат скалари или масиви. Ще се ограничим до скаларни начални и крайни стойности в този урок.
- num е броят на равномерно разположените точки. И това е незадължителен параметър със стойност по подразбиране 50.
- крайната точка също е незадължителен параметър, който може да бъде True или False.
- Стойността по подразбиране е True, което означава, че крайната точка ще бъде включена в интервала по подразбиране. Можете обаче да го зададете на False, за да изключите крайната точка.
- retstep е още един незадължителен параметър, който приема булевите стойности True или False. Когато е зададено на True, се връща стойността на стъпката.
- dtype е типът данни на числата в масива. Типът обикновено се извежда като float и не е необходимо да се предоставя изрично.
- axis е друг незадължителен параметър, обозначаващ оста, по която трябва да се съхраняват числата. И това е уместно само когато началната и крайната стойност са самите масиви.
▶️ Какво връща np.linspace()?
Връща N-измерен масив от равномерно разположени числа. И ако параметърът retstep е зададен на True, той също връща размера на стъпката.
Въз основа на дискусията досега, ето опростен синтаксис за използване на np.linspace():
np.linspace(start, stop, num)
Горният ред от код ще върне масив от num равномерно разположени числа в интервала [start, stop].
Сега, след като знаете синтаксиса, нека започнем да кодираме примери.
Как да създадете равномерно разпределени масиви с NumPy linspace()
#1. Като наш първи пример, нека създадем масив от 20 равномерно разположени числа в интервала [1, 5].
Можете да посочите стойностите на start, stop и num като аргументи на ключови думи. Това е показано в клетката с код по-долу:
import numpy as np arr1 = np.linspace(start = 1,stop = 5,num = 20) print(arr1) # Output: [1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737 4.78947368 5. ]
Забележете как числата в масива започват от 1 и завършват на 5 – включително и двете крайни точки. Също така, наблюдавайте как числата, включително точките 1 и 5, са представени като float в върнатия масив.
#2. В предишния пример сте предали стойностите за start, stop и num като аргументи на ключова дума. Ако подадете аргументите в правилния ред, можете също така да ги използвате като позиционни аргументи само със стойностите, както е показано по-долу.
import numpy as np arr2 = np.linspace(1,5,20) print(arr2) # Output: [1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737 4.78947368 5. ]
#3. Сега нека създадем друг масив, където задаваме retstep на True.
Това означава, че функцията ще върне както масива, така и стъпката. И можем да ги разопаковаме в две променливи arr3: масива и step_size: върнатия размер на стъпката.
Следната кодова клетка обяснява как можете да го направите.
import numpy as np arr3, step_size = np.linspace(1,5,20,retstep = True) print(arr3) # Output: [1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737 4.78947368 5. ] # Output: print(step_size) 0.21052631578947367
#4. Като последен пример, нека зададем крайна точка на False и да проверим какво се случва.
import numpy as np arr4 = np.linspace(1,5,20,endpoint = False) print(arr4) # Output: [1. 1.2 1.4 1.6 1.8 2. 2.2 2.4 2.6 2.8 3. 3.2 3.4 3.6 3.8 4. 4.2 4.4 4.6 4.8]
В върнатия масив можете да видите, че 1 е включено, докато 5 не е включено. И последната стойност в масива е 4,8, но все още имаме 20 числа.
Досега сме генерирали само масиви от равномерно разположени числа. В следващия раздел нека визуализираме, като начертаем тези числа.
Как да начертаете равномерно разположени числа в интервал
В този раздел нека изберем [10,15] като интересен интервал. След това използвайте np.linspace(), за да генерирате два масива, всеки съответно с 8 и 12 точки.
След като това приключи, можем да използваме функцията за чертане от библиотеката matplotlib, за да ги начертаем.
За по-голяма яснота ще захванем двата масива от N1 = 8 и N2 = 12 равномерно разположени точки на различни позиции по оста y.
Следният кодов фрагмент демонстрира това.
import numpy as np
import matplotlib.pyplot as plt
N1 = 8
N2 = 12
a = 10
b = 15
y1 = np.zeros(N1)
y2 = np.zeros(N2)
x1 = np.linspace(a, b, N1)
x2 = np.linspace(a, b, N2)
plt.plot(x1, y1-0.5, 'o')
plt.plot(x2, y2 + 0.5, 'o')
plt.ylim([-1, 1])
plt.title(f'Evenly Spaced Numbers in the Interval [{a},{b}]')
plt.xlabel('Interval')
plt.show()
Генерирането на равномерно разположени точки може да бъде полезно при работа с математически функции. Ще научим за това в следващия раздел.
Как да използвате NumPy linspace() с математически функции
След като сте генерирали масив от равномерно разположени числа с помощта на np.linspace(), можете да изчислите стойностите на математическите функции в интервала.
В кодовата клетка по-долу първо генерирате 50 равномерно разположени точки в интервала от 0 до 2π. И след това създайте масива y с помощта на np.sin() върху масива x. Обърнете внимание, че можете да пропуснете параметъра num, тъй като стойността по подразбиране е 50. Все още ще го използваме изрично.
Като следваща стъпка можете да начертаете функцията синус в интервала [0, 2π]. За да направите това, можете да използвате matplotlib, както в предишния пример. По-конкретно, функцията plot() в matplotlib.pytplot се използва за създаване на линейна графика.
import numpy as np
import matplotlib.pyplot as plt
N = 50
a = 0.0
b = 2*np.pi
x = np.linspace(a, b, N)
y = np.sin(x)
plt.plot(x, y, marker = "o")
plt.ylim([-1, 1])
plt.title(f'y = sin(x)')
plt.xlabel('x ---->')
plt.show()
Сега стартирайте горния код, като зададете N равно на 10. Ще получите диаграмата, както е показано на фигурата по-долу.
И можете да видите, че графиката не е много гладка – тъй като сте избрали само 10 точки в интервала.
Като цяло, колкото по-голям е броят на точките, които разглеждате, толкова по-гладък ще бъде графиката на функцията.
Заключение
Ето обобщение на това, което сме научили.
- np.linspace(start, stop, num) връща масив от num равномерно разположени числа в интервала [start, stop].
- Задайте крайната точка на незадължителния параметър на False, за да изключите спирането, и задайте интервала на[стартстоп)[startstop)
- Задайте retstep на True по желание, за да получите размера на стъпката.
- Генерирайте равномерно разпределени масиви с помощта на np.linspace() и след това използвайте масива с математически функции.
Надявам се, че вече разбирате как работи np.linspace(). Можете да изберете да изпълните горните примери в бележника на Jupyter. Вижте нашето ръководство за преносим компютър Jupyter или други алтернативи на Jupyter, които можете да разгледате.
Ще се видим скоро в друг урок за Python. Дотогава продължавайте да кодирате!😀