Numpy

NumPy jest podstawowym pakiet (dodatkowym) w Pythonie do obliczeń naukowych. Integruje on niskopoziomowe biblioteki takie jak BLAS i LAPACK lub ATLAS. Podstawowe właściwości NumPy to :

potężny N-wymiarowy obiekt tablicy danych
rozbudowane funkcje
narzędzia do integracji z kodem napisanym w C/C++ i Fortranie
narzędzia do algebry liniowej, transformaty Fouriera czy generator liczb losowych

NumPy is the fundamental package for scientific computing with Python. It contains among other things:

a powerful N-dimensional array object
sophisticated (broadcasting) functions
tools for integrating C/C++ and Fortran code
useful linear algebra, Fourier transform, and random number capabilities

Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases.

http://www.numpy.org/

Import



In [2]:

    
import numpy as np

Functions

np.abs()
np.sign()
np.sqrt()

Exponents and logarithms

np.log()
np.log10()
np.exp()

Trigonometric functions

np.sin()
np.cos()
np.tan()
np.arcsin()
np.arccos()
np.arctan()

Hiperbolic functions

np.sinh()
np.cosh()
np.tanh()
np.arcsinh()
np.arccosh()
np.arctanh()



In [ ]:

Random numbers

Mersenne Twister algorithm for pseudorandom number generation

Seed the generator



In [3]:

    
np.random.seed(293423)
np.random.rand(5)









    Out[3]:





array([0.33677247, 0.52693437, 0.79529578, 0.78867702, 0.02147624])



In [3]:

    
np.random.rand(5)









    Out[3]:





array([0.84612516, 0.0704939 , 0.1526965 , 0.77831701, 0.80821151])

Random values in a given shape

Random samples from a uniform distribution over [0, 1)



In [4]:

    
np.random.rand(2,3)









    Out[4]:





array([[0.84612516, 0.0704939 , 0.1526965 ],
       [0.77831701, 0.80821151, 0.82198398]])



In [9]:

    
np.random.rand(8).reshape((4,2))









    Out[9]:





array([[0.5219473 , 0.11240232],
       [0.65049125, 0.67164447],
       [0.3756778 , 0.09623913],
       [0.88756776, 0.33254026]])

Random integers from low (inclusive) to high (exclusive)



In [6]:

    
np.random.randint(5, 10)









    Out[6]:





6

Random numbers from distributions

Draw samples from a Poisson distribution

Poisson distribution with lambda = 6.0



In [176]:

    
np.random.seed(100)
np.random.poisson(6.0)









    Out[176]:





4



In [8]:

    
np.random.seed(100)
np.random.poisson([6.0, 1.0])









    Out[8]:





array([4, 0])

Draw random samples from a normal (Gaussian) distribution

Continuous normal (Gaussian) distribution with mean micro=1.5 and standard deviation sigma=4.0:



In [9]:

    
np.random.normal(1.5, 4.)









    Out[9]:





5.425283147804926

Continuous normal (Gaussian) distribution with mean micro=0.0 and standard deviation sigma=1.0:



In [10]:

    
np.random.normal()









    Out[10]:





0.5142188413943821



In [11]:

    
np.random.normal(size=5)









    Out[11]:





array([ 0.22117967, -1.07004333, -0.18949583,  0.25500144, -0.45802699])

Modify a sequence in-place by shuffling its contents



In [12]:

    
arr = np.arange(10)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

np.random.shuffle(arr)



In [13]:

    
arr









    Out[13]:





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

Multi-dimensional arrays are only shuffled along the first axis:



In [10]:

    
arr = np.arange(9).reshape((3, 3))
arr









    Out[10]:





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



In [11]:

    
np.random.shuffle(arr)
arr









    Out[11]:





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

Polynomials

Defining polynomial

$$Ax^3 + Bx^2 + Cx + D$$



In [13]:

    
np.poly([-1, 1, 10])









    Out[13]:





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

Calculating roots of a polynomial



In [15]:

    
np.roots([1., -10., -1., 10.])









    Out[15]:





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

Evaluate a polynomial at specific values



In [18]:

    
np.polyval([1, -10, -1, 10], 10)









    Out[18]:





0

Antiderivative (indefinite integral) of a polynomial



In [19]:

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









    Out[19]:





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

Derivatives



In [20]:

    
np.polyint([1, 1, 1, 1])









    Out[20]:





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

Least squares polynomial fit



In [21]:

    
x = [1, 2, 3, 4, 5, 6, 7, 8]
y = [0, 2, 1, 3, 7, 10, 11, 19]

np.polyfit(x, y, 2)









    Out[21]:





array([ 0.375     , -0.88690476,  1.05357143])

Polynomial Arithmetic

np.polyadd()
np.polysub()
np.polymul()
np.polydiv()



In [22]:

    
np.polyadd([1, 2], [9, 5, 4])









    Out[22]:





array([9, 6, 6])

Arrays

Create array

From list:



In [23]:

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









    Out[23]:





array([1, 2, 3])



In [24]:

    
np.array([1, 4, 5, 8], float)









    Out[24]:





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

From list of lists:



In [25]:

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









    Out[25]:





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

Generating arrays



In [26]:

    
np.arange(3)









    Out[26]:





array([0, 1, 2])



In [27]:

    
np.arange(3.)









    Out[27]:





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



In [28]:

    
np.arange(3, 7)









    Out[28]:





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



In [29]:

    
np.arange(3, 12, step=2)









    Out[29]:





array([ 3,  5,  7,  9, 11])



In [30]:

    
np.arange(start=3, stop=12, step=2, dtype=float)









    Out[30]:





array([ 3.,  5.,  7.,  9., 11.])

Slicing arrays



In [17]:

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









    Out[17]:





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



In [32]:

    
a[:2]









    Out[32]:





array([1., 4.])



In [35]:

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









    Out[35]:





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



In [33]:

    
a[3]









    Out[33]:





8.0



In [34]:

    
a[0] = 5
a









    Out[34]:





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



In [36]:

    
a[0][0]
a[0,0]









    Out[36]:





1.0



In [37]:

    
a[0]









    Out[37]:





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



In [38]:

    
a[1,:]









    Out[38]:





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



In [39]:

    
a[-1,-2]









    Out[39]:





5.0



In [40]:

    
a[-1,-2:]









    Out[40]:





array([5., 6.])



In [41]:

    
a[-1:,-2:]









    Out[41]:





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

Array shape



In [18]:

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









    Out[18]:





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



In [43]:

    
len(a)









    Out[43]:





2



In [44]:

    
a.shape









    Out[44]:





(2, 3)



In [19]:

    
a.dtype









    Out[19]:





dtype('float64')



In [24]:

    
a.astype(int)
a.dtype









    Out[24]:





dtype('int64')



In [23]:

    
a = a.astype(int)
a.dtype









    Out[23]:





dtype('int64')



In [48]:

    
6 in a









    Out[48]:





True



In [49]:

    
0 in a









    Out[49]:





False



In [25]:

    
a = np.array(range(10), float)



In [26]:

    
a = a.reshape((5, 2))
a









    Out[26]:





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



In [27]:

    
a.reshape((2, 5))









    Out[27]:





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



In [28]:

    
a









    Out[28]:





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



In [54]:

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



In [55]:

    
b = a
c = a.copy()



In [56]:

    
a[0] = 0



In [57]:

    
b









    Out[57]:





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



In [58]:

    
c









    Out[58]:





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



In [59]:

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









    Out[59]:





[[1.0, 2.0], [3.0, 4.0]]



In [60]:

    
list(a)









    Out[60]:





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



In [61]:

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



In [62]:

    
s = a.tostring()
s









    Out[62]:





b'\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@'



In [63]:

    
np.frombuffer(s)









    Out[63]:





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

Array Data



In [183]:

    
n1 = np.array([1,2,3])
n2 = np.array([[1,2],[3,4]])

print(f'Wymiar: n1: {n1.ndim}, n2: {n2.ndim}')

print(f'Kształt: n1: {n1.shape}, n2: {n2.shape}')

print(f'Rozmiar: n1: {n1.size}, n2: {n2.size}')

print(f'Typ: n1: {n1.dtype}, n2: {n2.dtype}')

print(f'Rozmiar elementu (w bajtach): n1: {n1.itemsize}, n2: {n2.itemsize}')

print(f'Wskaźnik do danych: n1: {n1.data}, n2: {n2.data}')









    



Wymiar: n1: 1, n2: 2
Kształt: n1: (3,), n2: (2, 2)
Rozmiar: n1: 3, n2: 4
Typ: n1: int64, n2: int64
Rozmiar elementu (w bajtach): n1: 8, n2: 8
Wskaźnik do danych: n1: <memory at 0x117c49ac8>, n2: <memory at 0x117de8048>

W przeciwieństwie do kolekcji, tablice mogą mieć tylko jeden typ elementu, choć może być złożony

https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html



In [184]:

    
for v in [1, 1., 1j]:
    a = np.array([v])
    print('Tablica: {}, typ: {}'.format(a, a.dtype))









    



Tablica: [1], typ: int64
Tablica: [1.], typ: float64
Tablica: [0.+1.j], typ: complex128

Array modification



In [64]:

    
a = np.arange(3)
a









    Out[64]:





array([0, 1, 2])



In [65]:

    
a.fill(0)
a









    Out[65]:





array([0, 0, 0])



In [178]:

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









    Out[178]:





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



In [179]:

    
a.transpose()









    Out[179]:





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



In [180]:

    
a.T









    Out[180]:





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



In [68]:

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









    Out[68]:





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



In [69]:

    
a.flatten()









    Out[69]:





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



In [70]:

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









    Out[70]:





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

       [[3.],
        [4.],
        [5.]]])



In [71]:

    
a.squeeze()









    Out[71]:





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

Math operations



In [72]:

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



In [73]:

    
a + b









    Out[73]:





array([6., 4., 9.])



In [74]:

    
a - b









    Out[74]:





array([-4.,  0., -3.])



In [75]:

    
a * b









    Out[75]:





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



In [76]:

    
b / a









    Out[76]:





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



In [77]:

    
a % b









    Out[77]:





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



In [78]:

    
b ** a









    Out[78]:





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



In [79]:

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



In [80]:

    
a * b









    Out[80]:





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

Array concatenation



In [181]:

    
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))









    Out[181]:





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

Array multiplication



In [81]:

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

a @ b









    Out[81]:





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



In [82]:

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

a * b









    Out[82]:





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

Shape operations



In [31]:

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









    Out[31]:





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



In [32]:

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









    Out[32]:





array([-1.,  3.])



In [33]:

    
a + b









    Out[33]:





array([[0., 5.],
       [2., 7.],
       [4., 9.]])



In [34]:

    
a = np.zeros((2,2), float)
a









    Out[34]:





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



In [35]:

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









    Out[35]:





array([-1.,  3.])



In [36]:

    
a + b









    Out[36]:





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



In [38]:

    
a + b [np.newaxis, :]









    Out[38]:





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



In [90]:

    
a + b [:, np.newaxis]









    Out[90]:





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

Other operations



In [91]:

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



In [92]:

    
np.sqrt(a)









    Out[92]:





array([1.04880885, 1.22474487, 1.37840488])



In [93]:

    
np.floor(a)









    Out[93]:





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



In [94]:

    
np.ceil(a)









    Out[94]:





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



In [95]:

    
np.rint(a)









    Out[95]:





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



In [96]:

    
np.pi









    Out[96]:





3.141592653589793



In [97]:

    
np.e









    Out[97]:





2.718281828459045



In [98]:

    
np.nan









    Out[98]:





nan



In [99]:

    
np.inf









    Out[99]:





inf

Array iteriation



In [100]:

    
a = np.array([1, 4, 5], int)

for x in a:
    print(x)



In [41]:

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

for x in a:
    print(x)









    



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

Array operations



In [102]:

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









    Out[102]:





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



In [103]:

    
a.sum()









    Out[103]:





9.0



In [104]:

    
a.prod()









    Out[104]:





24.0



In [105]:

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









    Out[105]:





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



In [106]:

    
a.mean()









    Out[106]:





4.0



In [107]:

    
a.var()









    Out[107]:





12.666666666666666



In [108]:

    
a.std()









    Out[108]:





3.559026084010437



In [109]:

    
a.min()









    Out[109]:





1.0



In [110]:

    
a.max()









    Out[110]:





9.0



In [111]:

    
a.argmin()









    Out[111]:





1



In [112]:

    
a.argmax()









    Out[112]:





2



In [113]:

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









    Out[113]:





[-1.0, 0.0, 2.0, 5.0, 6.0]



In [114]:

    
a.sort()
a









    Out[114]:





array([-1.,  0.,  2.,  5.,  6.])



In [115]:

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

a.clip(0, 5)









    Out[115]:





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



In [116]:

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

np.unique(a)









    Out[116]:





array([1., 4., 5., 7.])



In [117]:

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

a.diagonal()









    Out[117]:





array([1., 4.])

Comparison operators



In [118]:

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



In [119]:

    
a > b









    Out[119]:





array([ True, False, False])



In [120]:

    
a == b









    Out[120]:





array([False,  True, False])



In [121]:

    
a <= b









    Out[121]:





array([False,  True,  True])



In [122]:

    
c = a > b
c









    Out[122]:





array([ True, False, False])



In [123]:

    
any(c)









    Out[123]:





True



In [124]:

    
all(c)









    Out[124]:





False



In [44]:

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

np.logical_and(a > 0, a < 3)









    Out[44]:





array([ True, False, False])



In [126]:

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

np.logical_not(a)









    Out[126]:





array([False,  True, False])



In [127]:

    
a = np.array([True, False, True], bool)
b = np.array([False, True, False], bool)

np.logical_or(a, b)









    Out[127]:





array([ True,  True,  True])

Where



In [45]:

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

np.where(a != 0)









    Out[45]:





(array([0, 1]),)



In [129]:

    
b = np.array([1, 0, 3, 4, 0], float)

np.where(b != 0)









    Out[129]:





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



In [130]:

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

np.where(a != 0, a, None)  # for element ``a != 0`` return such element, otherwise ``None``









    Out[130]:





array([1.0, 3.0, None], dtype=object)



In [131]:

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

np.where(a != 0, a ** 2, a)









    Out[131]:





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



In [132]:

    
np.where(a != 0, a ** 2, 10)









    Out[132]:





array([ 1.,  9., 10.])

Nonzero



In [133]:

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









    Out[133]:





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

IsFinite and IsNaN



In [134]:

    
a = np.array([1, np.NaN, np.Inf], float)



In [135]:

    
np.isnan(a)









    Out[135]:





array([False,  True, False])



In [136]:

    
np.isfinite(a)









    Out[136]:





array([ True, False, False])

Array item selection and manipulation



In [46]:

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









    Out[46]:





array([[6., 4.],
       [5., 9.]])



In [138]:

    
a >= 6









    Out[138]:





array([[ True, False],
       [False,  True]])



In [139]:

    
a[a >= 6]









    Out[139]:





array([6., 9.])



In [140]:

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









    Out[140]:





array([6.])



In [47]:

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









    Out[47]:





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



In [142]:

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

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









    Out[142]:





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



In [52]:

    
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]









    Out[52]:





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



In [144]:

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

a.take(b)









    Out[144]:





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



In [145]:

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

a.take(b, axis=0)









    Out[145]:





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



In [146]:

    
a.take(b, axis=1)









    Out[146]:





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



In [147]:

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

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









    Out[147]:





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



In [148]:

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

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









    Out[148]:





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

Statistics

Compute the median along the specified axis



In [149]:

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

np.median(a)









    Out[149]:





3.0

Estimate a covariance matrix



In [150]:

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

np.cov(a)









    Out[150]:





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



In [151]:

    
np.cov(a, ddof=0)









    Out[151]:





array([[0.6875, 1.5625],
       [1.5625, 6.6875]])

Pearson product-moment correlation coefficients



In [152]:

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

np.corrcoef(a)









    Out[152]:





array([[1.        , 0.72870505],
       [0.72870505, 1.        ]])

Vector and matrix mathematics



In [153]:

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



In [154]:

    
np.dot(b, a)









    Out[154]:





array([ 6., 11.])



In [155]:

    
np.dot(a, b)









    Out[155]:





array([ 3., 13.])



In [156]:

    
np.dot(a, c)









    Out[156]:





array([[ 4.,  0.],
       [14.,  2.]])



In [157]:

    
np.dot(c, a)









    Out[157]:





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



In [158]:

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



In [159]:

    
np.outer(a, b)









    Out[159]:





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



In [160]:

    
np.inner(a, b)









    Out[160]:





10.0



In [161]:

    
np.cross(a, b)









    Out[161]:





array([ 4., -1., -6.])

Linear algebra



In [162]:

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

np.linalg.det(a)









    Out[162]:





-48.00000000000003



In [163]:

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

vals, vecs = np.linalg.eig(a)



In [164]:

    
vals









    Out[164]:





array([ 8.85591316,  1.9391628 , -2.79507597])



In [165]:

    
vecs









    Out[165]:





array([[-0.3663565 , -0.54736745,  0.25928158],
       [-0.88949768,  0.5640176 , -0.88091903],
       [-0.27308752,  0.61828231,  0.39592263]])



In [166]:

    
a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float)
b = np.linalg.inv(a)
b









    Out[166]:





array([[ 0.22916667,  0.04166667, -0.29166667],
       [ 0.04166667, -0.08333333,  0.58333333],
       [-0.3125    ,  0.125     ,  0.125     ]])



In [167]:

    
np.dot(a, b)









    Out[167]:





array([[1.00000000e+00, 5.55111512e-17, 0.00000000e+00],
       [0.00000000e+00, 1.00000000e+00, 2.22044605e-16],
       [0.00000000e+00, 1.38777878e-17, 1.00000000e+00]])

Matrix

Numpy ma również typ macierzy matrix. Jest on bardzo podobny do tablicy ale podstawowe operacje wykonywane są w sposób macierzowy a nie tablicowy.



In [168]:

    
a = np.matrix([[1,2], [3,4]])
b = np.matrix([[5,6], [7,8]])



In [169]:

    
a * b









    Out[169]:





matrix([[19, 22],
        [43, 50]])



In [170]:

    
a @ b









    Out[170]:





matrix([[19, 22],
        [43, 50]])



In [171]:

    
a ** 2









    Out[171]:





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



In [173]:

    
a * 2









    Out[173]:





matrix([[2, 4],
        [6, 8]])



In [185]:

    
a = np.diag([3,4])
a









    Out[185]:





array([[3, 0],
       [0, 4]])

Linear Algebra



In [187]:

    
a = np.matrix([[1,2], [3,4]])
print('det(a) = {}'.format(np.linalg.det(a)))









    



det(a) = -2.0000000000000004

Linear algebra basics

Function	Description
norm	Vector or matrix norm
inv	Inverse of a square matrix
solve	Solve a linear system of equations
det	Determinant of a square matrix
slogdet	Logarithm of the determinant of a square matrix
lstsq	Solve linear least-squares problem
pinv	Pseudo-inverse (Moore-Penrose) calculated using a singular value decomposition
matrix_power	Integer power of a square matrix
matrix_rank	Calculate matrix rank using an SVD-based method

Eigenvalues and decompositions

Function	Description
eig	Eigenvalues and vectors of a square matrix
eigh	Eigenvalues and eigenvectors of a Hermitian matrix
eigvals	Eigenvalues of a square matrix
eigvalsh	Eigenvalues of a Hermitian matrix
qr	QR decomposition of a matrix
svd	Singular value decomposition of a matrix
cholesky	Cholesky decomposition of a matrix

Tensor operations

Function	Description
tensorsolve	Solve a linear tensor equation
tensorinv	Calculate an inverse of a tensor

Exceptions

Function	Description
LinAlgError	Indicates a failed linear algebra operation

Assignments

Matrix multiplication

Używając numpy oraz operatora @ oraz *
Czym się różnią?

def matrix_multiplication(A, B):
    """
    >>> import numpy as np

    >>> A = np.array([[1, 0], [0, 1]])
    >>> B = [[4, 1], [2, 2]]
    >>> matrix_multiplication(A, B)
    [[4, 1], [2, 2]]

    >>> A = [[1,0,1,0], [0,1,1,0], [3,2,1,0], [4,1,2,0]]
    >>> B = np.matrix([[4,1], [2,2], [5,1], [2,3]])
    >>> matrix_multiplication(A, B)
    [[9, 2], [7, 3], [21, 8], [28, 8]]
    """
    pass

About

Filename: numpy-matrix-mul.py
Lines of code to write: 2 lines
Estimated time of completion: 5 min

Sum of inner matrix

Wygeneruj macierz (16x16) randomowych intów o wartościach od 10 do 100
Przekonwertuj macierz na typ float
Transponuj ją
Policz sumę środkowych (4x4) elementów macierzy
Wyświetl wartość (skalar) sumy, a nie nie wektor

About

Filename: numpy-sum.py
Lines of code to write: 4 lines
Estimated time of completion: 5 min

Szukanie liczby

Mamy liczbę trzycyfrową.
Jeżeli od liczny dziesiątek odejmiemy liczbę jedności otrzymamy 6.
Jeżeli do liczby dziesiątek dodamy liczbę jedności otrzymamy 10.
Znajdź wszystkie liczby trzycyfrowe spełniające ten warunek
Znajdź liczby trzycyfrowe podzielne przez 3

Hints

Ax=B
x=A−1B

liczba_dziesiatek - liczba_jednosci = 6
liczba_dziesiatek + liczba_jednosci = 10

liczba_dziesiatek = liczba_jednosci + 6
liczba_dziesiatek + liczba_jednosci = 10

liczba_dziesiatek = liczba_jednosci + 6
(liczba_jednosci + 6) + liczba_jednosci 10

liczba_dziesiatek = liczba_jednosci + 6
2 * liczba_jednosci + 6 = 10

liczba_dziesiatek = liczba_jednosci + 6
liczba_jednosci = 8 / 2

liczba_dziesiatek = 2 + 6
liczba_jednosci = 2

liczba_dziesiatek = 8
liczba_jednosci = 2

x1 - x2 = 6
x1 + x2 = 10

x1 = 6 + x2
6 + x2 + x2 = 10

2 * x2 = 4
x2 = 2
x1 = 8

import numpy as np

A = np.matrix([[1, -1], [1, 1]])
# matrix([[ 1, -1],
#        [ 1,  1]])

B = np.matrix([6, 10]).T  # Transpose matrix
# matrix([[ 6],
#        [10]])

x = A**(-1) * B
# matrix([[8.],
#        [2.]])

A*x == B
# matrix([[ True],
#        [ True]])

res1 = np.arange(1, 10)*100 + 10*x[0,0] + 1*x[1,0]
# array([182., 282., 382., 482., 582., 682., 782., 882., 982.])

res1[res1 % 3 == 0]
# array([282., 582., 882.])

m = res1 % 3 == 0
# array([False,  True, False, False,  True, False, False,  True, False])

res1[m]
# array([282., 582., 882.])

res2 = res1[m]
# array([282., 582., 882.])



In [ ]: