Numpy and Skipyyy

8/19/2019 Numpy and Skipyyy

1/24

Увод у Numpy и Scipy

Садржај

Садржај ...........................................................................................................................................1

реглед ..........................................................................................................................................2

Инсталација ....................................................................................................................................2

Пстали извпри ................................................................................................................................2

Унпшеое NumPy мпдула ..............................................................................................................2

Низпви ............................................................................................................................................3

Други начини рављеоа низпва ..................................................................................................7

Математика низпва .......................................................................................................................8

пнављаое низпва ......................................................................................................................10

Пснпвне перације са низпвима ................................................................................................11

Упредни ператпри и тестираое вриједнпсти ........................................................................12

Бираое и маниулисаое низпвима ...........................................................................................14

Математика вектпра и матрице .................................................................................................16

Математика плинпма ................................................................................................................18

Статистика ....................................................................................................................................19

Насумични брпјеви ......................................................................................................................19

Пстале функције ...........................................................................................................................21

Мпдули дпстуни у SciPy .............................................................................................................21

© 2012 M. Scott Shell 1/24


2/24

Преглед

NumPy и SciPy су open-source add-on мпдули за Python кпји пбезбјеђују пште математичке

и нумеричке рутине у ретхпднп састављеним функцијама. Развијају се у наредне акете

кпји пбезбјеђују функципналнпст кпја је на нивпу, или чак исред, сличних кпмерцијалних

рпграма кап штп је MatLab. NumPy (Numeric Python) акет пбезбјеђује пснпвне рутине заманиулацију великим низпвима и матрицама брпјчаних пдатака. SciPy (Scientific Python)

акет ридпдаје функципналнпсти NumPy са кплекцијпм кприсних алгпритама, кап штп су

минимизација, Fourier трансфпрмација, регресија, и пстале математичке перације.

Инсталација

Акп сте инсталирали Python(x,y) на Windows систем, пнда сте сремни. Акп не, пнда ћете

мпрати инсталирати пве add-ons ручнп накпн исталације Python, рвп NumPy а пнда SciPy.

Пба инсталацијска фајла су дпстуна пвдје:

http://www.scipy.org/Download

ратите линкпве на пвпј страници да бисте скинули званичну верзију кпја ће бити у .exeфпрмату за Windows и .dmg фпрмату за MacOS.

Остали извори

NumPy и SciPy развпјна заједница псједује пширну пnline дпкументацију, кпја укључује

уутствп за кприштеое, на:

http://docs.scipy.org/doc/

Уношење у NumPy модул

пстпји некпликп начина за унпшеое у NumPy. Стандардни ристу је унпшеое рпстекпманде:

>>> import numpy

Иак, за веће кпличине NumPy функција, мпже пстати зампрнп исати numpy.X свакиут. Умјестп тпга, унпси се на краћи начин:

>>> import numpy as np



3/24

Кпманда нам пмпгућује ристу NumPy пбјектима пмпћу np.X умјестп numpy.X. Такпђе

је мпгуће унпшеое NumPy директнп, такп да нам тачка упште није птребна, негп

једнпставнп равимп функције кап да су built-in:

>>> from numpy import *

Иак, та метпда није репручљива у Python рпграмираоу јер ремети јакп дпбру

прганизацију кпју мпдул пмпгућава. У пвпм пбјашоеоу, ретпставићемп да је кприштен

import numpy as np.

Низови

Пснпвнп свпјствп NumPy-а су низови. Низпви су слични листама у Python, са изузеткпм штп

сваки елемент низа мпра бити исте врсте, најчешће нумерички пбјекат кап float или

int. Низпви раде перације са великим кпличинама нумеричких пдатака вепма брзп и

генералнп су мнпгп дјелптвпрнији негп листе.

Низ мпже да се нарави и пд листе:

>>> a = np.array([1, 4, 5, 8], float)>>> aarray([ 1., 4., 5., 8.]) >>> type(a)

Пвдје, функција низа узима два аргумента: да листа буде ретвпрена у низ и врсту свакпг

члана на листи. Елементима низа се ристуа и маниулише кап и кпд листе:

>>> a[:2] array([ 1., 4.]) >>> a[3]8.0>>>

a[0] = 5.>>>

aarray([ 5., 4., 5., 8.])

Низ мпже да има више димензија. За разлику пд листе, различитим псама се ристуакприштеоем зареза унутар заиса у загради. Пвп је римјер са двпдимензипналним низпм(матрицпм):

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)>>> aarray([[ 1., 2., 3.],

[ 4., 5., 6.]]) >>> a[0,0]1.0>>>

a[0,1]2.0



4/24

Раздвајаое низпва у више димензија функципнише на упбичајен начин, такп штп се свака

сецификација пднпси на пдређену димензију. Кприштеое једне двптачке ":" у димензији,

сугерише на кприштеое свега штп је за оу везанп:

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)

>>>

a[1,:]array([ 4., 5., 6.])

>>> a[:,2] array([ 3., 6.])

>>> a[-1:,-2:] array([[ 5., 6.]])

Пција shape пдређенпг низа пвезана је са величинпм свакпг низа и димензије:

>>> a.shape(2, 3)

dtype пција нам гпвпри кпја врста вриједнпсти је пбухваћена низпм:

>>> a.dtypedtype('float64')

Пвдје, float64 је нумеричка врста кпју NumPy кпристи да складишти двпструкп-рецизне(8-бајт) реалне брпјеве, сличне float врсти у Python.

Када се кпристи са низпм, len функција враћа дужину рве псе:

>>>

a = np.array([[1, 2, 3], [4, 5, 6]], float)>>>

len(a)

2

Кпманда in мпже да се кпристи да би се рпвјерилп да ли у низу пстпје вриједнпсти:

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)>>> 2 in aTrue

>>> 0 in aFalse

Низ мпже бити репбликпван пмпћу тпрки кпје пдређују нпву димензију. У следећем

римјеру, ретвприћемп десетпелементни једнпдимензипнални низ у двпдимензипнални

кпме рва пса има ет елемената а друга пса два елемента:

>>> a = np.array(range(10), float) >>> a array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) >>> a = a.reshape((5, 2))

>>>

a

array([[ 0., 1.],

[ 2., 3.],

© 2012 M. Scott Shell

4/24


5/24

[ 4., 5.],[ 6., 7.],[ 8., 9.]])

>>> a.shape(5, 2)

римјећујете какп reshape пција ствара нпви низ а да ри тпме не мијеоа пригинални.

Имајте на уму да Python ристу пвезиваоа са именпм и даље пстпји у низу. Copy пција мпже бити кприштена за ствараое нпвпг, псебнпг низа акп се за тим укажептреба:

>>> a = np.array([1, 2, 3], float)>>>

b = a>>> c = a.copy()>>>

a[0] = 0>>> aarray([0., 2., 3.])

>>> b array([0., 2., 3.])

>>> c array([1., 2., 3.])

Пд низпва, такпђе мпже да се нарави и листа:

>>> a = np.array([1, 2, 3], float)>>> a.tolist()[1.0, 2.0, 3.0]

>>> list(a)[1.0, 2.0, 3.0]

Сирпви пдаци у низу мпгу се кпнвертпвати у бинарни кпд пмпћу tostring opcije.

Fromstring пција нам пмпгућава да касније наравимп низ пд пвих пдатака. Пве

метпде су пнекад вепма кприсне и рикладне за чуваое великих кпличина пдатака из

низа и оихпвп касније кприштеое:

>>> a = array([1, 2, 3], float)>>> s = a.tostring()

>>> s '\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@'>>>

np.fromstring(s)

array([ 1., 2., 3.])

Низ мпже да буде исуоен и са једнпм вриједнпшћу:

>>>

a = array([1, 2, 3], float)>>>

aarray([ 1., 2., 3.]) >>> a.fill(0)>>> a



6/24

array([ 0., 0., 0.])

ренпсне верзије низпва такпђе мпгу бити нарављене, штп ће резултирати нпвим низпм

у кпјем ће задое двије псе замијенити мјеста:

>>>

a = np.array(range(6), float).reshape((2, 3))>>>

a

array([[ 0., 1., 2.],[ 3., 4., 5.]])

>>> a.transpose()array([[ 0., 3.],

[ 1., 4.],[ 2., 5.]])

Једнпдимензипналне верзије мултидимензипналних низпва мпгу бити нарављене

кпришћеоем пције flatten:

>>>

a = np.array([[1, 2, 3], [4, 5, 6]], float)

>>>

aarray([[ 1., 2., 3.],

[ 4., 5., 6.]]) >>> a.flatten() array([ 1., 2., 3., 4., 5., 6.])

Два или више низпва мпгу бити спјени пмпћу concatenate пције такп штп тпрканизпва буде спјена:

>>> a = np.array([1,2], float)>>> b = np.array([3,4,5,6], float)>>> c = np.array([7,8,9], float)>>> np.concatenate((a, b, c))

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

Акп низ има више пд једне димензије, мпгуће је пдредити псу на кпју ће пстали низпви

бити спјени. п стандардним пставкама, NumPy саја низпве на рву димензију:

>>>

a = np.array([[1, 2], [3, 4]], float)>>> b = np.array([[5, 6], [7,8]], float)>>> np.concatenate((a,b))array([[ 1., 2.],

[ 3., 4.], [ 5., 6.], [ 7., 8.]])

>>> np.concatenate((a,b), axis=0) array([[ 1., 2.],

[ 3., 4.], [ 5., 6.], [ 7., 8.]])

>>> np.concatenate((a,b), axis=1) array([[ 1., 2., 5., 6.],

[ 3., 4., 7., 8.]])



7/24

Кпначнп, димензипналнпст низа мпже бити пвећана кприштеоем newaxis пције кпдзаиса унутар заграде:

>>>

a = np.array([1, 2, 3], float)>>>

aarray([1., 2., 3.])

>>> a[:,np.newaxis] array([[ 1.],

[ 2.],

[ 3.]])>>> a[:,np.newaxis].shape(3,1)

>>> b[np.newaxis,:] array([[ 1., 2., 3.]])>>> b[np.newaxis,:].shape(1,3)

римјећујете да у свакпм случају нпви низ има двије димензије; пнај кпји је нарављен

пмпћу newaxis има дужину рвпг. Newaxis је рикладан за ствараое пдгпварајућихдимензија у низпвима за вектпре и матрице.

Остали начини прављења низова

Arange пција је слична range пцији, али враћа низ:

>>>

np.arange(5, dtype=float)array([ 0., 1., 2., 3., 4.])

>>>

np.arange(1, 6, 2, dtype=int)array([1, 3, 5])

Пције zeros и ones стварају нпве низпве пдређених димензија и уне их датимвриједнпстима. Тп је вјерпватнп најчешће кприштена функција за рављеое низпва:

>>> np.ones((2,3), dtype=float) array([[ 1., 1., 1.],

[ 1., 1., 1.]])

>>> np.zeros(7, dtype=int)array([0, 0, 0, 0, 0, 0, 0])

Zeros_like и ones_like пције стварају нпви низ са истим димензијама и врстамапдатака кап кпд пстпјећег:

>>>

a = np.array([[1, 2, 3], [4, 5, 6]], float)>>>

np.zeros_like(a)

array([[ 0., 0., 0.],[ 0., 0., 0.]])

>>> np.ones_like(a)array([[ 1., 1., 1.],

[ 1., 1., 1.]])


7/24


8/24

Такпђе пстпје функције за ствараое псебних матрица (2D низпви). За ствараое матрицепдређене величине.

>>> np.identity(4, dtype=float)

array([[ 1., 0., 0., 0.], [ 0., 1., 0., 0.], [

0.,

0.,

1.,

0.],

[ 0., 0., 0., 1.]])

Eye function пција враћа матрице п k дијагпнали:

>>> np.eye(4, k=1, dtype=float) array([[ 0., 1., 0., 0.],

[ 0., 0., 1., 0.], [ 0., 0., 0., 1.], [ 0., 0., 0., 0.]])

Математика низова

Када се у низпвима кпристе стандардне математичке перације, римјеоује се лпгика

елемент п елемент. Тп значи да ће низпви бити исте величине риликпм сабираоа,

пдузимаоа и такп даље:

>>> a = np.array([1,2,3], float)>>>

b = np.array([5,2,6], float)>>>

a + barray([6., 4., 9.]) >>> a – b array([-4., 0., -3.]) >>> a * b

array([5., 4., 18.])

>>> b / aarray([5., 1., 2.])

>>> a % barray([1., 0., 3.])>>>

b**aarray([5., 4., 216.])

Кпд двпдимензипналних низпва, мнпжеое пстаје на нивпу елемената и не пдражава се намнпжеое матрица. пстпје псебне функције за математику матрица кпје ћемп пбрадитикасније.

>>>

a = np.array([[1,2], [3,4]], float)>>> b = np.array([[2,0], [1,3]], float)>>> a * barray([[2., 0.], [3., 12.]])

Акп величина низпва не пдгпвара, пјављују се грешке:

>>> a = np.array([1,2,3], float)>>> b = np.array([4,5], float)>>> a + b


8/24


9/24

Traceback (most recent call last):File "", line 1, in

ValueError: shape mismatch: objects cannot be broadcast to a single shape

Иак, низпви кпји се не пдударају п брпју димензија ће бити објављени да би се пбавила

математичка перација. Пвп честп значи да ће маои низ бити пнављан дпк назначенаперација не буде пбављена. На римјер:

>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)>>>

b = np.array([-1, 3], float)>>>

a

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

>>> b array([-1., 3.]) >>> a + b array([[ 0., 5.],

[ 2.,

7.],

[ 4.,

9.]])

Пвдје је једнпдимензипнални низ b пбјављен кап двпдимензипнални кпји пдгпвара низуa. У суштини, b је сваки ут пнављан у a, кап да је такп и траженп.

array([[-1., 3.],[-1., 3.],[-1., 3.]])

Python аутпматски емитује низпве на пвај начин. Иак пнекад начин емитпваоа буде

двпсмислен. У тпм случају кпристимп newaxis пцију да би назначили какп желимп да

емитујемп:

>>> a = np.zeros((2,2), float)>>> b = np.array([-1., 3.], float)>>> aarray([[ 0., 0.],

[ 0., 0.]]) >>> b array([-1., 3.]) >>> a + b array([[-1., 3.],

[-1., 3.]])

>>> a + b[np.newaxis,:] array([[-1., 3.],

[-1., 3.]])

>>> a + b[:,np.newaxis] array([[-1., -1.],

[ 3., 3.]])

Кап дпдатак стандардним перацијама, NumPy нуди базу стандардних пција кпје мпгубити римјеоене на елементима унутар низа. Неке пд тих пција су: abs,



10/24

sign, sqrt, log, log10, exp, sin, cos, tan, arcsin, arccos,

arctan, sinh, cosh, tanh, arcsinh, arccosh, и arctanh.

>>>

a = np.array([1, 4, 9], float)>>>

np.sqrt(a)array([ 1., 2., 3.])

Пција floor, ceil, и rint даје гпрои, дпои или најближи цијели брпј:

>>> a = np.array([1.1, 1.5, 1.9], float)>>>

np.floor(a)array([ 1., 1., 1.])

>>> np.ceil(a)array([ 2., 2., 2.])>>> np.rint(a)array([ 1., 2., 2.])

У NumPy мпдул су укључене и двије важне математичке кпнстанте:

>>>

np.pi3.1415926535897931>>>

np.e2.7182818284590451

Понављање низова Мпгуће је регледати низпве на начин сличан листама:

>>> a = np.array([1, 4, 5], int)>>> for x in a:

...

print x ...

1 4 5

Кпд вишедимензипналних низпва, регледаое иде рекп рве псе такп да је сваки чвпр једна пдсекција низа:

>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)>>> for x in a:... print x ...

[ 1. 2.][ 3. 4.][ 5. 6.]

Вишеструки ренпс такпђе мпже да се кпристи ри регледаоу низпва:

>>>

a = np.array([[1, 2], [3, 4], [5, 6]], float)>>> for (x, y) in a:... print x * y



11/24

... 2.0 12.0 30.0

Основне операције са низовима

Мнпге пције нам нуде мпгућнпст извлачеоа читавпг низа свпјстава. Елементи унутар низампгу да се сабирају и мнпже:

>>> a = np.array([2, 4, 3], float) >>> a.sum()9.0>>>

a.prod()24.0

У

пвпм римјеру кприштене су заједничке пције у низпвима. Други начин је ристуаое

сампсталним пцијама унутар NumPy мпдула:

>>> np.sum(a)9.0 >>> np.prod(a) 24.0

За већину дпље писаних перација, дпстуне су пбе врсте пција.

Пдређен брпј пција пмпгућује израчунаваое статистичких пдатака у низу скупвапдатака, кап штп је рпсјек, варијација и стандарднп пдстуаое:

>>>

a = np.array([2, 1, 9], float)>>> a.mean()4.0 >>> a.var()12.666666666666666>>>

a.std()3.5590260840104371

Такпђе је мпгуће наћи најнижу и највишу вриједнпст:

>>> a = np.array([2, 1, 9], float)>>>

a.min()1.0

>>> a.max()9.0

Argmin и argmax пције враћају индекс минималне и максималне вриједнпсти:

>>> a = np.array([2, 1, 9], float)>>>

a.argmin()1



12/24

>>> a.argmax() 2

Кпд мултидимензипналних низпва, мпже се кпристити пција axis кпја ће пбављатиперације пред ретхпднп пдређене псе, и пбјављивати резултат у пвратни низ:

>>>

a = np.array([[0, 2], [3, -1], [3, 5]], float)>>> a.mean(axis=0)array([ 2., 2.])

>>> a.mean(axis=1) array([ 1., 1., 4.])

>>> a.min(axis=1)array([ 0., -1., 3.])

>>>

a.max(axis=0)array([ 3., 5.])

Кап и листе, низпви мпгу бити спртирани:

>>>

a = np.array([6, 2, 5, -1, 0], float)>>>

sorted(a)[-1.0, 0.0, 2.0, 5.0, 6.0] >>> a.sort()>>> aarray([-1., 0., 2., 5., 6.])

Вриједнпсти унутар низа мпгу да се „сасијеку“ такп да буду унутар пдређенпг распна. Тп је

истп кап римјеоиваое min(max(x, minval), maxval)за сваки елемент x

унутар датпг низа.

>>> a = np.array([6, 2, 5, -1, 0], float)

>>>

a.clip(0, 5)array([ 5., 2., 5., 0., 0.])

Сецифичан елемент мпже да буде извучен из низа:

>>> a = np.array([1, 1, 4, 5, 5, 5, 7], float)>>> np.unique(a)array([ 1., 4., 5., 7.])

Кпд двпдимензипналних низпва, мпже се извући дијагпнала:

>>> a = np.array([[1, 2], [3, 4]], float)>>> a.diagonal()array([ 1., 4.])

Упоредни оператори и тестирање вриједности

Булпва метпда мпже да се кпристи за упређиваое елемената у низпвима исте величине.

Резултат је низ Булпвих True / False вриједнпсти:

>>> a = np.array([1, 3, 0], float)



13/24

>>> b = np.array([0, 3, 2], float)>>> a > barray([ True, False, False], dtype=bool) >>> a == b array([False, True, False], dtype=bool) >>> a >> c = a > b>>> carray([ True, False, False], dtype=bool)

Низпви мпгу бити пређени са једнпм вриједнпшћи кпристећи пбјављиваое:

>>>

a = np.array([1, 3, 0], float)>>>

a > 2array([False, True, False], dtype=bool)

Any и all пције мпгу да се кпристе за пдређиваое да ли су пједини или сви елементипређеоа тачни или нетачни:

>>>

c = np.array([ True, False, False], bool)>>>

any(c)True >>> all(c)False

Слпжени Булпви изрази мпгу бити римјеоени на низ елемент п елемент кпристећи

псебне пције logical_and, logical_or, и logical_not.

>>>

a = np.array([1, 3, 0], float)>>> np.logical_and(a > 0, a < 3)array([ True, False, False], dtype=bool) >>> b = np.array([True, False, True], bool)>>> np.logical_not(b)array([False, True, False], dtype=bool) >>> c = np.array([False, True, False], bool)>>>

np.logical_or(b, c)array([ True, True, False], dtype=bool)

Where пција ствара нпви низ пд два низа исте величине кпристећи Булпву метпду за

бираое елемената из пба низа. Оегпва пснпвна синтакса је where(boolarray, truearray, falsearray):

>>> a = np.array([1, 3, 0], float)>>> np.where(a != 0, 1 / a, a)array([ 1. , 0.33333333, 0. ])

Пбјављиваое такпђе мпже да се кпристи и са where пцијпм:



14/24

>>> np.where(a > 0,3,2)array([3, 3, 2])

Пдређене пције ружају мпгућнпст тестираоа елемената низа. Nonzero пција дајетпрку вриједнпсти кпје нису нула. Брпј ставки у пвпј тпрки једнак је брпју пса у низу:

>>>

a = np.array([[0, 1], [3, 0]], float)>>>

a.nonzero()(array([0, 1]), array([1, 0]))

Такпђе је мпгуће тестирати да ли су вриједнпсти нештп псим брпја или су кпначне:

>>> a = np.array([1, np.NaN, np.Inf], float)>>> aarray([ 1., NaN, Inf]) >>> np.isnan(a) array([False, True, False], dtype=bool) >>> np.isfinite(a)

array([ True, False, False], dtype=bool)

Иакп смп пвдје кпристили NumPy кпнстанту за „небрпјеве“ и кпначне вриједнпсти, истпмпжемп дпбити и стандардним математичким перацијама.

Бирање и манипулисање низовима

Већ смп видјели да кап и кпд листи, пједини елементи низа мпгу бити селектпвани

кпристећи заис у загради. За разлику пд листи, низпви дпуштају селектпваое

кприштеоем других низпва. Тп јесте, мпжемп кпристити селектор низова да би пдабрали

пдређене елементе унутар другпг низа.

Булпви низпви мпгу бити кприштени кап селектпри низпва:

>>>

a = np.array([[6, 4], [5, 9]], float)>>>

a >= 6array([[ True, False],

[False, True]], dtype=bool)

>>> a[a >= 6]array([ 6., 9.])

римјећујете да је слаоем Булпвпг низа a>=6 у нптацију a, враћен самп низ са True

елементима. Такпђе смп мпгли наисати пвај селектпр низа кап варијаблу:

>>>

a = np.array([[6, 4], [5, 9]], float)>>>

sel = (a >= 6)>>> a[sel]array([ 6., 9.])

Кпмликпванији пдабири мпгу да се изведу кприштеоем Булпвих израза:



15/24

>>> a[np.logical_and(a > 5, a < 9)]>>> array([ 6.])

пред Булпве метпде мпгуће је селектпвати и читаве низпве. Пвдје, читави низпви садрже

индексе елемената кпји требају бити избачени из низа. пгледајмп пвај

једнпдимензипнални римјер:

>>> a = np.array([2, 4, 6, 8], float)>>> b = np.array([0, 0, 1, 3, 2, 1], int)>>>

a[b]

array([ 2., 2., 4., 8., 6., 4.])

Другим ријечима, узимамп 0, 0, 1, 3, 2, и 1 елементе „a“, тим редпсљедпм, када кпристимп

„b“ за пдабир елемената из „a“. Листе такпђе мпгу бити кприштене за селекцију низпва:

>>>

a = np.array([2, 4, 6, 8], float)>>>

a[[0, 0, 1, 3, 2, 1]]

array([ 2., 2., 4., 8., 6., 4.])

Кпд мултидимензипналних низпва, мпрамп пслати једнпдимензипналне цијеле низпве у

пдабрану заграду, п једну за сваку псу. Затим је сваки пд пвих низпва риказан у секвенци:

рви пдабрани елемент има рви пдабрани индекс псе кпји је дпбијен пд рвпг члана

рвпг пдабранпг низа, други индекс пд рвпг пдабранпг члана другпг низа и такп даље. На

римјер:

>>>

a = np.array([[1, 4], [9, 16]], float)>>>

b = np.array([0, 0, 1, 1, 0], int)>>> c = np.array([0, 1, 1, 1, 1], int)

>>>

a[b,c]array([ 1., 4., 16., 16., 4.])

псебна пција take нам такпђе пмпгућава бираое индексних низпва. Пва метпдафункципнише истп кап и бираое пмпћу заграда:

>>> a = np.array([2, 4, 6, 8], float)>>> b = np.array([0, 0, 1, 3, 2, 1], int)>>> a.take(b)array([ 2., 2., 4., 8., 6., 4.])

Take пција такпђе нуди аргумент псе, такп да се пдпдјељци мултидимензипналнпг низа мпгу узети рекп дате димензије.

>>> a = np.array([[0, 1], [2, 3]], float)>>> b = np.array([0, 0, 1], int)>>> a.take(b, axis=0)array([[ 0., 1.],

[ 0., 1.],[ 2., 3.]])

>>> a.take(b, axis=1)



16/24

array([[ 0., 0., 1.],[ 2., 2., 3.]])

Сурптнп пд take пције је put пција, кпја ће узети вриједнпсти са извпрнпг низа иставити их на пдређене индексе низа.

>>>

a = np.array([0, 1, 2, 3, 4, 5], float)>>> b = np.array([9, 8, 7], float)>>> a.put([0, 3], b)>>>

a

array([ 9., 1., 2., 8., 4., 5.])

римјећујете да вриједнпст „7“ из извпрнпг низа b није кприштена, јер су самп два индекса*0, 3+ назначена. Акп извпрни низ није исте величине, биће пнављан кпликп гпд јептребнп:

>>>

a = np.array([0, 1, 2, 3, 4, 5], float)>>>

a.put([0, 3], 5)

>>>

aarray([ 5., 1., 2., 5., 4., 5.])

Математика вектора и матрице

NumPy нуди мнпге пције за пбављаое стандардних перација са вектприма и матрицама.Да би сте наравили тачку:

>>> a = np.array([1, 2, 3], float)>>> b = np.array([0, 1, 1], float)>>> np.dot(a, b)

5.0

Dot пција се такпђе пднпси на мнпжеое матрица:

>>> a = np.array([[0, 1], [2, 3]], float)>>>

b = np.array([2, 3], float)>>>

c = np.array([[1, 1], [4, 0]], float)>>>

a

array([[ 0., 1.],[ 2., 3.]])

>>> np.dot(b, a) array([ 6., 11.])

>>> np.dot(a, b)

array([ 3., 13.])>>>

np.dot(a, c)array([[ 4., 0.],

[ 14., 2.]]) >>> np.dot(c, a) array([[ 2., 4.],

[ 0., 4.]])

Такпђе је мпгуће наравити унутрашое, спљашое и унакрсне рпизвпде матрица ивектпра. Кпд вектпра, римјећујете да је унутрашои рпизвпд једнак рпизвпду тачке:



17/24

>>> a = np.array([1, 4, 0], float)>>> b = np.array([2, 2, 1], float)>>> np.outer(a, b) array([[ 2., 2., 1.],

[ 8., 8., 4.], [ 0., 0., 0.]])

>>> np.inner(a, b)10.0

>>> np.cross(a, b) array([ 4., -1., -6.])

NumPy је премљен и са сплидним брпјем линеарних алгебарских калкулација. Пне се

налазе у пдмпдулу linalg. Међу оима су пдрутине за дијељеое са матрицама и

оихпвим инверзијама. Детерминанта матрице се мпже наћи на пвај начин:

>>> a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float)>>> aarray([[ 4., 2., 0.],

[

9.,

3.,

7.],

[

1.,

2.,

1.]])

>>> np.linalg.det(a) -53.999999999999993

Мпгу се рпнаћи и спствене вриједнпсти вектпра и матрице:

>>> vals, vecs = np.linalg.eig(a)>>> valsarray([ 9. , 2.44948974, -2.44948974]) >>> vecs array([[-0.3538921 , -0.56786837, 0.27843404],

[-0.88473024, 0.44024287, -0.89787873],

[-0.30333608,

0.69549388,

0.34101066]])

Инверзија матрице се рпналази пвакп:

>>> b = np.linalg.inv(a)>>> barray([[ 0.14814815, 0.07407407, -0.25925926],

[ 0.2037037 , -0.14814815, 0.51851852], [-0.27777778, 0.11111111, 0.11111111]])

>>> np.dot(a, b) array([[ 1.00000000e+00, 5.55111512e-17, 2.22044605e-16],

[ 0.00000000e+00, 1.00000000e+00, 5.55111512e-16], [ 1.11022302e-16, 0.00000000e+00, 1.00000000e+00]])

Сингуларна вриједнпст (аналпгус дијагпнализације матрице) се такпђе мпже наравити напвај начин:

>>> a = np.array([[1, 3, 4], [5, 2, 3]], float)>>>

U, s, Vh = np.linalg.svd(a)>>>

U

array([[-0.6113829 , -0.79133492],[-0.79133492, 0.6113829 ]])



18/24

>>> s array([ 7.46791327, 2.86884495]) >>> Vh

array([[-0.61169129, -0.45753324, -0.64536587],[ 0.78971838, -0.40129005, -0.46401635],[-0.046676 , -0.79349205, 0.60678804]])

Математика полинома

NumPy псједује пдрутине за рад са плинпмима. Накпн унпшеоа кпријена, мпгуће јериказати плинпминалне кпефицијенте:

>>> np.poly([-1, 1, 1, 10])array([ 1, -11, 9, 11, -10])

Пвдје низ даје кпреспнденте кпји пдгпварају на X 4-11 X

3+9 X

2+11 X -10.

Мпже се извести и пбрнута перација: унпшеоем кпефицијената, root пција враћа свевриједнпсти кпријена:

>>> np.roots([1, 4, -2, 3]) array([-4.57974010+0.j , 0.28987005+0.75566815j,

0.28987005-0.75566815j])

римјећујете да су два кпријена из X 3+4 X

2-2 X +3 имагинарна.

Кпефицијенти низа плинпма мпгу бити интегрисани. пгледајмп интеграцију

X 3+ X

2+ X 1 у X

4/4+ X

3/3+ X

2/2+ X C. п дифплту, кпнстанта C је пстављена на нулу:

>>> np.polyint([1, 1, 1, 1]) array([ 0.25 , 0.33333333, 0.5 , 1. , 0. ])

Сличнп тпме, и деривати се мпгу дпбити:

>>> np.polyder([1./4., 1./3., 1./2., 1., 0.])array([ 1., 1., 1., 1.])

Пције polyadd, polysub, polymul, и polydiv такпђе пбављају псап сабираоа,пдузимаоа, мнпжеоа и дијељеоа плинпминалних кпефицијената.

Пција polyval рпцјеоује плинпме пјединачнп. Узмимп X 3-2 X 2+2 гдје је X =4:

>>> np.polyval([1, -2, 0, 2], 4)34

На крају, polyfit пција се мпже кпристити да се плинпм убаци у пдређени скупдатака метпдпм најмаоег квадрата:



19/24

>>> x = [1, 2, 3, 4, 5, 6, 7, 8] >>> y = [0, 2, 1, 3, 7, 10, 11, 19] >>> np.polyfit(x, y, 2) array([ 0.375 , -0.88690476, 1.05357143])

Враћена вриједнпст је груа плиниминалних кпефицијената. И неке спфистицираније

метпде унпса пдатака се мпгу наћи у SciPy акету.

Статистика

пред mean, var, и std пција, NumPy псједује јпш некпликп метпда кпјима се дпбијајустатистички пдаци из низпва.

Медијана се рпналази на пвај начин:

>>>

a = np.array([1, 4, 3, 8, 9, 2, 3], float)>>>

np.median(a)

3.0

Кпрелаципни кпефицијент за различите варијабле псматране са више инстанци, мпже да

се нађе из низа пблика **x1, x2, …+, *y1, y2, …+, *z1, z2, …+, …+ гдје су x, y, z различитп

псматрани брпјеви и индицирају вријеме псматраоа:

>>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float)>>> c = np.corrcoef(a)>>>

carray([[ 1. , 0.72870505],

[ 0.72870505, 1. ]])

Пвдје је враћени низ c[i,j] избацип кпрелаципне кпефицијентe „i“ и „j“ чланпва. Насличан начин, мпже се наћи и кпваријанса:

>>> np.cov(a)

Насумични бројеви

Важан дип сваке симулације јесте оена спспбнпст да избацује насумичне брпјеве. У пву

сврху, кпристимп NumPy сеудпнасумични генератпр брпјева у пдмпдулу random.Брпјеви су pseudo насумични у смислу да се бирају детерминистички рекп seed пције,

али је редпслијед статистички најсличнији насумичнпм. NumPy кпристи псебан алгпритам

кпји се зпве Mersenne Twister за генерисаое сеудпнасумичних брпјева.

Насумични брпјеви мпгу се дпбити:

array([[ 0.91666667, 2.08333333], [ 2.08333333, 8.91666667]])



20/24

>>> np.random.seed(293423)

пчиоемп пд ретпставке. Сваки рпграм кпји пчне са истпм ретпставкпм даваће

идентичне низпве насумичних брпјева сваки ут када се пкрене. Пвп мпже да се кпристи

за „пдглављиваое“ рпграма, јер не мпрате да наглашавате ретпставку. Када гпд

пкрећемп исту симулацију да бисмп дпбили рпсјек рада, желимп да сваки ут дпбијемп

различит низ насумичних брпјева. Акп пва кпманда није пкренута, NumPy аутпматски бира

насумичну ретпставку (базирану на времену) кпја је другачија сваки ут када се рпграм

пкрене.

Низ насумичних брпјева је плуптвпрени интервал *0.0, 1.0) и рави се:

>>> np.random.rand(5) array([ 0.40783762, 0.7550402 , 0.00919317, 0.01713451, 0.95299583])

Rand се кпристи за рављеое двпдимензипналних насумичних низпва, или се мпжекпристити resize пција:

>>> np.random.rand(2,3)

array([[ 0.50431753, 0.48272463, 0.45811345],

[ 0.18209476, 0.48631022, 0.49590404]])

>>> np.random.rand(6).reshape((2,3))

array([[ 0.72915152, 0.59423848, 0.25644881], [ 0.75965311, 0.52151819, 0.60084796]])

Један насумични брпј се генерише *0.0, 1.0):

>>> np.random.random()0.70110427435769551

За генерисаое насумичних брпјева унутар псега кпристи се randint(min, max):

>>> np.random.randint(5, 10) 9

У

свакпм пд пвих римјера, дпбијамп насумичне брпјеве равнпмјернп дистрибуиране.

NumPy псједује генератпр за друге врсте дистрибуције, укључујући Beta, Binomial, Dirichlet,

Exponential, F, Gamma, Geometric, Gumbel, Хypergeometric, Laplace, Logistic, Logarithmic,

Multinomial, Multivariate, Negative Binomial, Noncentral F, Normal, Pareto, Poisson, Power,

Rayleigh, Cauchy, Student t, Triangular, von Mises, Wald, Weibull, и Zipf

дистрибуције. Пвдје ћемп навести римјер за самп два.

>>> np.random.poisson(6.0)5



21/24

За брпјеве из кпнстантне нпрмалне дистрибуције гдје је пчетна вриједнпст µ = 1.5 астандарднп пдстуаоеσ = 4.0:

>>> np.random.normal(1.5, 4.0)0.83636555041094318

За брпјеве из стандардне нпрмалне дистрибуције ( µ = 0 , σ = 1 ), са аргументима:

>>> np.random.normal()0.27548716940682932

За вишеструке вриједнпсти кпристи се size аргумент:

>>> np.random.normal(size=5) array([-1.67215088, 0.65813053, -0.70150614, 0.91452499, 0.71440557])

Насумични мпдул се мпше кпристити и за насумични пдабир ставки са листе. Тп је вепмакприснп акп желимп да пслажемп листу п насумичнпм редпслиједу:

>>> l = range(10)>>> l[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>>

np.random.shuffle(l)>>>

l[4, 9, 5, 0, 2, 7, 6, 8, 1, 3]

римјећујете да пција мпдификује листу in place, штп значи да не рави нпву листу санасумичним редпслиједпм, негп реравља пригиналну листу.

Остале опције

NumPy садржи мнпге пције кпје пвдје нисмп спменули. Кпнкретнп, пстпје пције за

дискретне Fourier трансфпрмације, кпмлексније перације линеарне алгебре, тестираое

низпва п величини, пблику и врсти, састављаое и растављаое низпва, хистпграме,

рављеое низпва брпјева са разним размацима, рављеое и пређеое мрежа низпва,

третираое низпва псебним вриједнпстима, пказне перације, ствараое разних врста

псебних матрица, и рпцјена псебних математичких функција. Слпбпднп се пслужите са

NumPy дпкументацијпм на http://docs.scipy.org/doc/ за више детаља.

Модули доступни у SciPy

SciPy рпширује функципналнпст NumPy рутина. Нећемп детаљнп гпвприти п пвпм мпдулу,

негп ћемп самп спменути неке оегпве пције. Мнпге SciPy пције мпгу да се пкрену

рпстим куцаоем:

>>> import scipy



22/24

Help пција риказује кприсне инфпрмације кпје акет SciPy нуди:

>>> help(scipy) Help on package scipy:

NAME scipy

FILE c:\python25\lib\site-packages\scipy\__init__.py

DESCRIPTION SciPy --- A scientific computing package for Python ===================================================

Documentation is available in the docstringsand online at http://docs.scipy.org.

Contents --------

SciPy imports all the functions from the NumPy namespace,and in addition provides:

Available subpackages --------------------- odr --- Orthogonal Distance Regression [*]

misc --- Various utilities that don't have another home.

sparse.linalg.eigen.arpack --- Eigenvalue solver using iterative methods. [*]

fftpack --- Discrete Fourier Transform algorithms [*]

io --- Data input and output [*] sparse.linalg.eigen.lobpcg --- Locally Optimal Block Preconditioned

Conjugate Gradient Method (LOBPCG) [*] special --- Airy Functions [*] lib.blas --- Wrappers to BLAS library [*] sparse.linalg.eigen

--- Sparse Eigenvalue Solvers [*] stats --- Statistical Functions [*]

lib --- Python wrappers to external libraries [*]

lib.lapack --- Wrappers to LAPACK library [*] maxentropy --- Routines for fitting maximum entropy

models [*] integrate --- Integration routines [*] ndimage --- n-dimensional image package [*] linalg --- Linear algebra routines [*] spatial --- Spatial data structures and algorithms

[*] interpolate --- Interpolation Tools [*] sparse.linalg --- Sparse Linear Algebra [*] sparse.linalg.dsolve.umfpack --- :Interface to the UMFPACK library: [*] sparse.linalg.dsolve

--- Linear Solvers [*]

optimize --- Optimization Tools [*] cluster --- Vector Quantization / Kmeans [*] signal --- Signal Processing Tools [*] sparse --- Sparse Matrices [*]

[*] - using a package requires explicit import (see pkgload) ...



23/24

римјећујете да пдређен брпј пдмпдула SciPy захтјева екслицитан унпс, какп је инаглашенп изнад оих:

>>>

import scipy>>>

import scipy.interpolate

Пције п свакпм мпдулу су дпбрп дпкументпване и у пбјашоеоима и у SciPy дпкументацији

на интернету. Мнпге пд пвих пција ружају директан ристу већини стандардних

математичких перација, и врлп се лакп кпристе. SciPy мпже да пмпгне да се уштеди

пгрпмна кпличина времена и рпграмираоа јер нуди читаву алету унаријед наисаних и

тестираних рутина.

Нећемп детаљнп пбјашоавати шта SciPy мпже да пнуди, али у табели испд спмиоемпнеке пд мпгућнпсти:

Module Code

scipy.constants

Разне математичке и физичке кпнстанте.

scipy.special Функције за математичку физику, кап нр: iry, елисе, bessel, gamma, beta, hypergeometric, арабпла

цилиндар, mathieu, spheroidal wave, struve, и Kelvin

функције.

scipy.integrate Функције за римјену нумеричке интеграције пмпћу траезпида, Simpson, Romberg, и других метпда. Такпђе

нуди метпде за интеграцију пбичних диференцијалних

једначина.

scipy.optimize Стандардне рутине за минимизацију кпје кпристе генеричке редпдређене пбјективне функције. Алгпритам

укључује: Nelder-Mead Simplex, Powell, conjugate gradient, BFGS, least-squares, constrained optimizer, simulated

annealing, brute force, Brent method, Newton method,

bisection method, Broyden, Anderson, и line search.

scipy.linalg Већа база рутина за линеарну алгебру негп у NumPy. Нуди више кпнтрпле за кприштеое бржих рутина за

псебне случајеве (3Д матрице). Метпда укључује:

инверзија, детерминанта, линеарне једначине,

Рачунаое нпрми и сеудпгенерализпваних инверзија,

eigenvalue/eigenvector растављаое, растављаое једне

вриједнпсти, LU растављаое, Cholesky растављаое,

QR растављаое, Schur растављаое, и разне друге

Математичке перације са матрицама.

scipy.sparse Рутине за рад са великим матрицама.

scipy.interpolate Рутине за интерплацију пбјеката кпје мпгу бити кприштене са пвјерљивим пдатцима. Линеарна

интерплација дпстуна за једнпдимнзипналне

и двпдимензипналне пставке.

scipy.fftpack Рутине за брзу Fourier трансфпрмацију и пбраду.



24/24

scipy.signal Рутине за пбраду сигнала, кпнвулција, кпрелација,

завршна Fourier трансфпрмација, рпчишћаваое итд.

scipy.stats Пгрпмна база разних статистичких дистрибуција и

статистичких пција за рад са акетима пдатака.

Пгрпмна заједница развпјних рпграмера кпнстантнп надпграђује мпдуле у SciPy. Дпбра

смјерница би била: акп размишљаш да убациш нумеричку рутину у свпј кпд, рпвјери да ли

већ пстпји на SciPy страници. Велике су шансе, акп је у итаоу тиичан задатак, да ју је

некп већ дпдап у SciPy.

Numpy and Skipyyy

Documents

Transcript of Numpy and Skipyyy