1.2 NumPy - Podstawy

Kilka przydatnych komend:

Komenda NumPy	Opis
a.ndim	zwraca liczbę wymiarów
a.shape	zwraca liczbę wierszy i kolumn
arange(start,stop,step)	zwraca wektor sekwencji
linspace(start,stop,steps)	zwraca sekwencję o równych odstępach z określonego przedziału
dot(a,b)	mnożenie macierzy
vstack([a,b])	pionowo skleja tablice `a` i `b`
hstack([a,b])	poziomo skleja tablice `a` i `b`
where(a>x)	zwraca elementy tablicy spełniające podany warunek

Podstawowe operacje arytmetyczne

Operatory arytmetyczne działają w NumPy element po elemencie.



In [40]:

    
a = np.array([3,4,5])
b = np.ones(3)
a - b









    Out[40]:





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

Zaskakujące może być działanie operatora *, który nie oblicza iloczynu macierzy. Odpowiada za to funkcja dot.



In [42]:

    
a = np.array([[1,2],[3,4]])
b = np.array([[1,2],[3,4]])
a









    Out[42]:





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



In [43]:

    
b









    Out[43]:





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



In [44]:

    
a * b









    Out[44]:





array([[ 1,  4],
       [ 9, 16]])



In [45]:

    
np.dot(a,b)









    Out[45]:





array([[ 7, 10],
       [15, 22]])

Inne operacje dodawania i mnożenia



In [47]:

    
a = np.zeros((2,2),dtype='float')
a += 5
a









    Out[47]:





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



In [48]:

    
a *= 5
a









    Out[48]:





array([[ 25.,  25.],
       [ 25.,  25.]])



In [49]:

    
a + a









    Out[49]:





array([[ 50.,  50.],
       [ 50.,  50.]])

Sklejanie tablic



In [50]:

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









    Out[50]:





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



In [51]:

    
np.vstack([a,b,c])









    Out[51]:





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

Typowe funkcje matematyczne



In [52]:

    
x = np.arange(1,5)
np.sqrt(x) * np.pi









    Out[52]:





array([ 3.14159265,  4.44288294,  5.44139809,  6.28318531])



In [53]:

    
2**4









    Out[53]:





16



In [54]:

    
np.power(2,4)









    Out[54]:





16



In [55]:

    
np.log(np.e)









    Out[55]:





1.0



In [56]:

    
x = np.arange(5)
x.max() - x.min()









    Out[56]:





4

tablice jednowymiarowe zachowują sie podobnie do zwykłych list pythonowych.



In [57]:

    
a = np.arange(10)
a[2:4]









    Out[57]:





array([2, 3])



In [58]:

    
a[:10:2]









    Out[58]:





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



In [59]:

    
a[::-1]









    Out[59]:





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

Wielowmiarowy tablice mają po jednym indeksie na wymiar



In [60]:

    
x = np.arange(12).reshape(3,4)
x









    Out[60]:





array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])



In [61]:

    
x[2,3]









    Out[61]:





11



In [62]:

    
x[:,1]









    Out[62]:





array([1, 5, 9])



In [63]:

    
x[1,:]









    Out[63]:





array([4, 5, 6, 7])



In [64]:

    
x[1:3,:]









    Out[64]:





array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])



In [65]:

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









    Out[65]:





(array([], dtype=int64),)



In [66]:

    
a[a==3]









    Out[66]:





array([3, 3, 3])



In [67]:

    
np.where(a<3)









    Out[67]:





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



In [68]:

    
np.where(a<3)[0]









    Out[68]:





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



In [69]:

    
np.where(a>9)









    Out[69]:





(array([], dtype=int64),)



In [70]:

    
for row in x:
    print row









    



[0 1 2 3]
[4 5 6 7]
[ 8  9 10 11]



In [71]:

    
for element in x.flat:
    print element



In [72]:

    
np.random.randint(0,10,5)









    Out[72]:





array([2, 1, 8, 1, 0])



In [73]:

    
np.random.normal(0,1,5)









    Out[73]:





array([-1.39421131, -1.86519392, -1.05505174,  0.51611756,  1.18944997])



In [74]:

    
np.random.uniform(0,2,5)









    Out[74]:





array([ 1.94821411,  0.97440973,  1.41912929,  0.02273456,  1.6993009 ])