3_numpy


Analiza danych i uczenie maszynowe w Python

Autor notebooka: Jakub Nowacki.

NumPy

NumPy jest podstawowym pakie (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 codem napisanym w C/C++ i Fortranie
  • narzędzia do algebry liniowej, transformaty Fouriera czy generator liczb losowych

Numpy importujemy używając nazwy numpy, najlepiej w całości jako pakiet. Często stosowany jest alias np.


In [0]:
import numpy as np

Tablica

Podstawowym obiektem w Numpy jest tablica zwana ndarray od ang. N-dimensional array. Talbicę można stworzyć z kolekcji za pomocą funkcji ndarray lub jej aliasu array:


In [3]:
n1 = np.array([1,2,3])
print(n1)
n2 = np.array([[1,2],[3,4]])
n2
# ... itd


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

Każda komenda ma poniższe właściwości:


In [4]:
print('Wymiar: n1: {}, n2: {}'.format(n1.ndim, n2.ndim))
print('Kształt: n1: {}, n2: {}'.format(n1.shape, n2.shape))
print('Rozmiar: n1: {}, n2: {}'.format(n1.size, n2.size))
print('Typ: n1: {}, n2: {}'.format(n1.dtype, n2.dtype))
print('Rozmiar elementu (w bajtach): n1: {}, n2: {}'.format(n1.itemsize, n2.itemsize))
print('Wskaźnik do danych: n1: {}, n2: {}'.format(n1.data, n2.data))


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

W przeciwieństwie do kolekcji, tablice mogą mieć tylko jeden typ elementu, choć moze być złożony; zobacz ten link.


In [5]:
for v in [1, 1., 1j]:
    a = np.array([v])
    print('Tablica: {}, typ: {}'.format(a, a.dtype))
# Można też wymusić typ przy tworzeniu tablicy
a = np.array([1], dtype=str)
print('Tablica: {}, typ: {}'.format(a, a.dtype))


Tablica: [1], typ: int32
Tablica: [1.], typ: float64
Tablica: [0.+1.j], typ: complex128
Tablica: ['1'], typ: <U1

Są też ogólne metody tworzenia tablic o specyficznych właściwościach:


In [6]:
print('Zakres:\n{}'.format(np.arange(1,10)))
print('Zera:\n{}'.format(np.zeros((2,3))))
print('Jedynki:\n{}'.format(np.ones((3,2))))
print('Pusta:\n{}'.format(np.empty((2,7)))) # Bez inicjalizacji
print('Losowa:\n{}'.format(np.random.rand(2,2)))


Zakres:
[1 2 3 4 5 6 7 8 9]
Zera:
[[0. 0. 0.]
 [0. 0. 0.]]
Jedynki:
[[1. 1.]
 [1. 1.]
 [1. 1.]]
Pusta:
[[1.01855798e-312 1.18831764e-312 1.01855798e-312 9.54898106e-313
  1.06099790e-312 1.03977794e-312 1.23075756e-312]
 [1.20953760e-312 1.06099790e-312 9.76118064e-313 1.01855798e-312
  1.01855798e-312 1.16709769e-312 4.44659081e-322]]
Losowa:
[[0.6468727  0.76909227]
 [0.89730518 0.13993221]]

Pobieranie wartości z tablic:


In [7]:
# Jak w kolekcjach
print(n1[1], n2[1][1])
# ... ale jest też skrót
print(n2[1,1])
# Przecięcia podobnie w kolekcjach
print(n2[1,:])
print(n2[:,1])
print(n2[1,:1])


2 4
4
[3 4]
[2 4]
[3]

Operacje w tablicach wykonywane są na poszczególnych elementach, np. jak pomnożymy dwie tablice pomnożone zostaną tylko elementy na tych samych pozycjach przez siebie.


In [8]:
a = np.random.randint(100,size=(2,3))
print('a = \n{}'.format(a))
print('2*a = \n{}'.format(2*a))
print('a**2 = \n{}'.format(a**2))
print('a*a = \n{}'.format(a*a))


a = 
[[38  5 91]
 [26 33 65]]
2*a = 
[[ 76  10 182]
 [ 52  66 130]]
a**2 = 
[[1444   25 8281]
 [ 676 1089 4225]]
a*a = 
[[1444   25 8281]
 [ 676 1089 4225]]

Macierze

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 [9]:
m = np.matrix([[1,2], [3,4]])
mm = np.matrix([[5,6], [7,8]])

print('m*mm = \n{}'.format(m*mm))
print('m**2 = \n {}'.format(m**2))
print('m*2 = \n ={}'.format(m*2))

d = np.diag([3,4])
print('d = \n {}'.format(d))
print('d*m = \n {}'.format(d*m))


m*mm = 
[[19 22]
 [43 50]]
m**2 = 
 [[ 7 10]
 [15 22]]
m*2 = 
 =[[2 4]
 [6 8]]
d = 
 [[3 0]
 [0 4]]
d*m = 
 [[ 3  6]
 [12 16]]

Niemniej, tablice można używać podobnie, ale do mnożenia trzeba wykorzystywać funkcje dot:


In [10]:
a = np.array([[1,2], [3,4]])
aa = np.array([[5,6], [7,8]])

print('a*aa = \n{}'.format(a*aa))
print('a.dot(aa) = \n{}'.format(a.dot(aa)))
print('a**2 = \n {}'.format(a**2))
print('a*2 = \n ={}'.format(a*2))


a*aa = 
[[ 5 12]
 [21 32]]
a.dot(aa) = 
[[19 22]
 [43 50]]
a**2 = 
 [[ 1  4]
 [ 9 16]]
a*2 = 
 =[[2 4]
 [6 8]]

Dodatkowo, operacje algebry liniowej można wykonywać zarówno na tablicach jak i macierzach, np:


In [ ]:
print('det(m) = {}'.format(np.linalg.det(m)))
print('det(a) = {}'.format(np.linalg.det(a)))

Zadanie

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

Podpowiedź: $$ Ax=B $$ $$ x = A^{-1}B $$


In [36]:
"""
liczba_trzycyfrowa = 282

liczba_dziesiatek = 8
liczba_jednosci = 2

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]

In [ ]: