Wstęp

Artykuły w tym cyklu:

Podstawy pakietu Numpy - część 1
Podstawy pakietu Numpy - część 2
Podstawy pakietu Pandas - część 1
Podstawy pakietu Pandas - część 2
Wizualizacja danych - podstawy pakietu Matplotlib

Numpy jako wstęp do data science

Na blogu postanowiłem zacząć opisywać nowy większy temat związany ze wstępem do zagadnień data science. Pakiet Numpy, od numeric python, jest według mnie pierwszym etapem na drodze do zgłębienia tematyki analizy danych i tematów z nią związanych. Opiera się na nim bezpośrednio wiele pakietów, które będziemy tu w późniejszym czasie opisywać, np. Pandas, Matplotlib, czy Scikit-Learn.

Głównym obiektami, z które korzystamy w całym pakiecie, są wielowymiarowe, jednorodne tablice (ndarrays od n-dimension array). Jednorodność oznacza, że wszystkie elementy tablicy muszą być tego samego typu. W zależności od wymiaru tabeli mówimy o jej osiach. Tablice jednowymiarowe, odzwierciedlające wektory, mają jedną oś. Tablice dwuwymiarowe mają 2 osie, jedną odpowiadającą wierszą, a drugą kolumną.

Podstawy obiektu ndarray

Po zaimportowaniu pakietu do jupyter notebook'a możemy sprawdzić podstawowe właściwości obiektu ndarray. Na początek utworzymy dwie tablice, jedno i dwuwymiarową, odpowiednio a i b. Pominę na razie opis tworzenia tablic, skupimy się na nim w następnym podrozdziale.

Kod tego i kolejnych wpisów dotyczących data science będzie przedstawiany jako fragmenty jupyter notbook-ów. Są to fragmenty notatnika wyeksportowanego do formatu html, stąd też czytelnik może kopiować poszczególne komórki i odpalać je u siebie w celu przećwiczenia omawianych tu zagadnień.

In [1]:

import numpy as np

In [2]:

a = np.array([1.3, 2., 3.9, 4., 5.1])
a

Out[2]:

array([1.3, 2. , 3.9, 4. , 5.1])

In [3]:

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

Out[3]:

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

Podstawowymi metodami służącymi do opisu tablicy są ndarray.shape zwracający tuplę z ilością wierszy i kolumn tablicy oraz ndarray.ndim która zwraca ilość wymiarów tablicy.

In [4]:

a.shape

Out[4]:

(5,)

In [5]:

b.shape

Out[5]:

(2, 3)

In [6]:

b.ndim

Out[6]:

Dodatkowo przydatna często okazuje się możliwość sprawdzenia sumarycznej ilości elementów w tablicy, czyli ilości wierszy pomnożonej przez ilość kolumn, służy do tego ndarray.size. Typ elementów w tablicy zwraca ndarray.dtype. Jest to jedna liczna, gdyż wszystkie elementy w tablicy muszą być tego samego typu.

In [7]:

b.size

Out[7]:

In [8]:

a.dtype

Out[8]:

dtype('float64')

Typy danych NumPy

Pakiet NumPy rozszerza zbiór typów danych znanych z pythona, wiele z nich zaczerpniętych jest z C i różnią się możliwą długością zapisanych w nich danych, oto przykłady:

np.int8 - Byte (-128 to 127)

np.int16 - Integer (-32768 to 32767)

np.int32 - Integer (-2147483648 to 2147483647)

np.uint8 - Unsigned integer (0 to 255)

...

np.float32 - float

np.float64 - double float - ta sama precyzja co wbudowany float pythona

np.complex64 - float complex - liczba zespolona

Najczęściej używanymi typami są int64 i float64.

Tworzenie tablic

Tablice w NumPy możemy tworzyć na wiele sposobów, podstawowym jest przekazanie do metody np.array() obiektu, po którym można iterować. Mogą to być np. pythonowe listy czy tuple, przekazane bezpośrednio, lub jako zmienna na nie wskazująca.

In [9]:

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

Out[9]:

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

In [10]:

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

Out[10]:

dtype('int64')

In [11]:

b = np.array([1.9, 0.2, 11.])
b.dtype

Out[11]:

dtype('float64')

Tablica przyjmie typ danych, które zostały przekazane w momencie jej tworzenia. Jeśli wartości będą liczbami całkowitymi, typem danych po utworzeniu tablicy będzie int64, a dla liczb zmiennoprzecinkowych float64. Warto pamiętać, że podstawowym typem dla ndarray jest właśnie float64, stąd też, jeśli wartości przekazane przy tworzeniu tablicy będą mieszane (float i int), wynikowa tablica będzie miała dtype='float64', a wszystkie wartości całkowite zostaną przekonwertowane.

W momencie tworzenia tablicy możemy również zdefiniować jakiego typu dane mają się w niej znaleźć, za pomocą parametru dtype. NumPy postara się przekonwertować wszystkie wartości do zadanego typu.

In [12]:

c = np.array([1, 2, 3], dtype='float32')
c

Out[12]:

array([1., 2., 3.], dtype=float32)

Pakiet NumPy udostępnia nam również wiele metod automatycznego tworzenia tablic według konkretnych szablonów. Przykładowe to np.zeros() tworząca tablicę o zadanym rozmiarze, wypełnioną samymi zerami (jest analogiczna metoda p.ones() z jedynkami), czy p.eye(), zwracająca kwadratową tablicę, na której głównej przekątnej są jedynki, a reszta to zera.

Za pomocą metody np.full((row, col), fill_value) stworzymy tablicę, o zadanym kształcie, której wszystkie pola będą równe zadanej w parametrze fill_value wartości.

Nieco bardziej skomplikowana jest ostatnia z pokazanych poniżej metod, czyli np.empty(). Jako parametry przyjmuje ona podobnie jak wyżej wymiary wynikowej tablicy. Różni się ona od np.fill() tym, że wypełnia tablicę przypadkowymi wartościami zależnymi od stanu pamięci w momencie jej wywołania.

In [13]:

np.zeros((3, 3))

Out[13]:

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

In [14]:

np.eye(2)

Out[14]:

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

In [15]:

np.full((3, 4), 2)

Out[15]:

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

In [16]:

np.empty((3,3))

Out[16]:

array([[0.34906585, 0.6981317 , 1.04719755],
       [1.3962634 , 1.74532925, 2.0943951 ],
       [2.44346095, 2.7925268 , 3.14159265]])

Często będziemy potrzebowali wytworzyć tablicę (zazwyczaj jednowymiarową - wektor), posiadającą dokładnie określoną ilość elementów z jakiegoś konkretnego przedziału. Przychodzą nam wtedy z pomocą dwie metody: np.arange() i np.linspace(). Pierwsza działa podobnie jak pythonowe range() przyjmując start, stop i step, i zwracając jednowymiarową tablicę liczb zdefiniowanych tymi parametrami.

Nieznacznie inaczej działa np.linspace(), w której spośród trzech parametrach definiujemy również start i stop, ostatni parametr jednak określa na ile równo oddalonych od siebie wartości wydzielić z przedziału [start, stop]. Bardzo przydatna metoda przy generowaniu zbioru wartości potrzebnego do zbudowania wykresu.

In [17]:

np.arange(5)

Out[17]:

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

In [18]:

np.arange(1, 10, 2)

Out[18]:

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

In [19]:

np.linspace(0, np.pi, 10)

Out[19]:

array([0.        , 0.34906585, 0.6981317 , 1.04719755, 1.3962634 ,
       1.74532925, 2.0943951 , 2.44346095, 2.7925268 , 3.14159265])

Na koniec pozostało tworzenie tablic wypełnionych randomowymi wartościami. Pakiet NumPy posiada wiele metod spełniających to zadanie, chciałbym się tu jednak skupić na dwóch, różniących się od siebie zwracanym zakresem, z jakiego wybierana jest randomowa wartość.

Metoda np.random.rand() zwraca tablicę o zadanym kształcie wypełnioną przypadkowymi wartościami z przedziału [0, 1). Natomiast metoda np.random.randint() poza wymiarami tablicy przyjmuje ponadto zakres, z jakiego mają zostać wygenerowane losowe wartości całkowite. Górna wartość nie wchodzi do zakresu.

In [20]:

np.random.rand(3,2)

Out[20]:

array([[0.24998296, 0.82311212],
       [0.45842003, 0.81463788],
       [0.46138329, 0.67196011]])

In [21]:

np.random.randint(2, 5, (3,2))

Out[21]:

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

In [22]:

np.random.rand()

Out[22]:

0.7862749611786373

In [23]:

np.random.randint(0, 10)

Out[23]:

Obie powyższe metody mogą również służyć do generowania pojedynczych wartości, jeśli tylko pominiemy w parametrach wymiary wynikowej tablicy.

Zmiana wymiarów tablicy

Kolejną ważną funkcjonalności NumPy jest możliwość zmiany kształtu tablic. Jak już wiemy parametr ndarray.shape pozwala nam sprawdzić długość osi tablicy, czyli dla tablicy 2D ilość jej kolumn i wierszy. Za pomocą metody ndarray.reshape() możemy wygenerować nową tablicę na podstawie innej tablicy, zadając jej konkretne wymiary. Trzeba jednak pamiętać, że rows * columns muszą dawać sumaryczną ilość elementów w tablicy.

In [24]:

a = np.arange(1, 10)
a

Out[24]:

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

In [25]:

b = a.reshape(3,3)
b

Out[25]:

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

Metodą bardzo podobną do ndarray.reshape() jest metoda ndarray.resize(), przyjmuje ona również ilość wierszy i kolumn oczekiwanej tablicy. Różnica polega na tym, że .reshape() zwraca nową tablicę, którą trzeba zapisać do zmiennej w celu zachowania, .resize() natomiast zmienia wymiary tablicy, na której zostało wykonane.

In [26]:

a.resize(3,3)
a

Out[26]:

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

Często będziemy korzystali z NumPy do wykonywania operacji związanych z macierzami, bardzo przydatna wtedy okaże się transpozycja macierzy (naszej tablicy), czyli odwrócenie jej przez główną oś. W numpy wykonujemy ją za pomocą metody ndarray.T.

Prostą i przydatną metodą jest również ndarray.ravel(), która spłaszcza tablicę do jednowymiarowej.

In [27]:

a.T

Out[27]:

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

In [28]:

a.ravel()

Out[28]:

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

Często, przy dużych tablicach, zwłaszcza tych z większą niż dwa liczbą wymiarów, nie jesteśmy w stanie prosto i szybko określić jakie wartości powinniśmy zadać do .reshape() aby idealnie pokryły ilość elementów tablicy. Wiemy np., że potrzebujemy 3 wiersze. Możemy wtedy zadać metodzie .reshape() wartość -1, w miejsce wymiaru, którego nie znamy, a metoda sama dopasuje pasującą wartość.

In [29]:

np.linspace(0, 3, 12).reshape(3, -1)

Out[29]:

array([[0.        , 0.27272727, 0.54545455, 0.81818182],
       [1.09090909, 1.36363636, 1.63636364, 1.90909091],
       [2.18181818, 2.45454545, 2.72727273, 3.        ]])

Podstawowe operacje

Cechą tablic NumPy, która definitywnie pokazuje ich wyższość nad zwykłymi tablicami z pythona, jest sposób, w jaki przeprowadzane są na nich operacje matematyczne. Mianowice operacje przeprowadzana są kolejno na wszystkich elementach.

In [30]:

a = np.arange(5)
a

Out[30]:

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

In [31]:

b = np.array([3.2, 4., 0.8, 1., 3.1])
b

Out[31]:

array([3.2, 4. , 0.8, 1. , 3.1])

In [32]:

a + b

Out[32]:

array([3.2, 5. , 2.8, 4. , 7.1])

Opisując to na przykładzie dodawanie dwóch tablic, każdy element wynikowej tablicy jest sumą elementów obu tablic na tej samej pozycji. Warunkiem takiego zachowania, są te same wymiary obu tablic. Odstępstwa od tej zasady zostaną omówione, gdy będę opisywał "Broadcasting".

Możemy również wykonywać operacje na tablicach, gdzie drugim składnikiem operacji jest skalar. Potęgowania tablicy spowoduje, że w wynikowej tablicy każdy z elementów będzie podniesiony do potęgi.

In [33]:

a**2

Out[33]:

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

Natomiast wykonanie operacji logicznych, typu większy niż, mniejszy niż itp., zwraca tablicę o tym samym kształcie, gdzie każdy z jej elementów odpowiada wynikowi logicznej operacji przeprowadzonej na elemencie wejściowej tablicy.

In [34]:

b > 3

Out[34]:

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

Zasadniczą cechą powyższych operacji jest tworzenie nowej tablicy, którą, aby zachować trzeba zapisać do zmiennej. Da się jednak w prosty sposób zmienić to zachowanie, używając do tych prostych operacji zapisu +=, *= itp. znanych z pythona.

In [35]:

b += a
b

Out[35]:

array([3.2, 5. , 2.8, 4. , 7.1])

Pakiet NumPy daje nam również możliwość wykonać w prosty sposób tak zwane operacje jednoargumentowe na całych tablicach. Mowa to o np. znalezieniu sumy wszystkich elementów - ndarray.sum(), wartości największej i najmniejszej - ndarray.max(), ndarray.min() itp.

In [36]:

c = np.arange(0, 12).reshape(3, 4)
c

Out[36]:

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

In [37]:

c.sum()

Out[37]:

In [38]:

c.min()

Out[38]:

In [39]:

c.max(axis=1)

Out[39]:

array([ 3,  7, 11])

Każda z powyższych operacji zwraca pojedynczy wynik dla całej tablicy. Można to zachowanie zmienić, podając która oś ma zostać zredukowana. W powyższym wypadku zadając axis=1, mówimy metodzie .max(), aby zredukowała kolumny do jednej i przedstawiła w niej największe wartości dla wszystkich wierszy. Pamiętajmy, że w NumPy oś 0 to oś wierszy, a 1 oś kolumn.

Warto również dodać, że gdy przeprowadzamy operacje na dwóch tablicach lub tablicy i wartości skalarnej i posiadają one różne typy danych, wynikowa tablica odziedziczy dokładniejszy typ danych. Czyli gdy np. pomnożymy tablicę z dtype=int64 przez pojedynczą wartość mającą dtype=float64, cała wynikowa tablica będzie zawierała liczby zmiennoprzecinkowe.

Uniwersalne funkcje NumPy

Pakiet NumPy udostępnia również użytkownikom zestaw przygotowanych funkcji, które przyjmują tablicę i zwracają wynik określonej operacji matematyczne, przeprowadzonej element po elemencie, jako tablicę o tych samych wymiarach. W skrócie nazywane są unfunc od Universal Functions. Możemy dzięki nim przeprowadzić wiele przydatnych operacji jak liczenie potęg, pierwiastków czy wartości funkcji trygonometrycznych.

Większość z nich pozwala również na podanie jako argument wartości skalarnej, zwracają wtedy również wynik obliczeń jako wartość skalarną.

In [40]:

np.exp(a)

Out[40]:

array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692, 54.59815003])

In [41]:

np.sqrt(a)

Out[41]:

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

In [42]:

np.sin(a)

Out[42]:

array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ])

Lista wszystkich dostępnych funkcji z odnośnikami do ich specyfikacji dostępna jest tutaj

Indexing & Slicing

Kolejnym niezmiernie ważnym elementem pracy z tablicami NumPy jest możliwość wybierania pojedynczych elementów bądź podtabel na podstawie konkretnych indeksów. W przypadku jednowymiarowych tablic indeksowanie wygląda dokładnie tak jak w przypadku tabel pythona. Możemy wybierać pojedyncze elementy bądź całe fragmenty podając index początku i końca wycinka oddzielone dwukropkiem my_array[1:3]. Pamiętajmy, że końcowy index nie wchodzi do wycinka - [start, stop). Podobnie jak w przypadku tablic możemy pominąć pierwszy element, gdy wycinek zaczyna się od 0 (np. my_array[:2]) i analogicznie, gdy kończy się na ostatnim elemencie.

In [43]:

a = np.arange(10)
a

Out[43]:

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

In [44]:

a[3]

Out[44]:

In [45]:

a[5:7]

Out[45]:

array([5, 6])

In [46]:

a[:4]

Out[46]:

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

In [47]:

a[-1]

Out[47]:

Gdy mamy do czynienia z tablicami o większej niż jeden liczbie wymiarów, do indeksowania i tworzenia wycinków nie używamy znanej z pythona składni array[x][y]. W NumPy indeksy dla poszczególnych osi zapisujemy w pojedynczym kwadratowym nawiasie, oddzielone od siebie przecinkiem.

Dla dwuwymiarowych tablic pierwsza wartość określa wiersza, a druga kolumny. Tutaj również wycinki określamy, oddzielając początek i koniec znakiem dwukropka.

In [48]:

b = np.array([[1, 2, 3, 4], [11, 12, 13, 14], [21, 22, 23, 24]])
b

Out[48]:

array([[ 1,  2,  3,  4],
       [11, 12, 13, 14],
       [21, 22, 23, 24]])

In [49]:

b[0,0]

Out[49]:

In [50]:

b[1:, 1:3]

Out[50]:

array([[12, 13],
       [22, 23]])

Jeśli natomiast podamy mniej indeksów, niż tablica ma wymiarów, brakujące indeksy zostaną uzupełnione znakiem :, czyli pobrane zostaną wszystkie elementy.

In [51]:

b[2]

Out[51]:

array([21, 22, 23, 24])

Nie wyczerpuje to oczywiście możliwości indeksowania i wycinania fragmentów tablic. Po bardziej szczegółowe informacje i więcej przykładów odsyłam do dokumentacji. Tematy związane z indeksowaniem zostaną również poruszone w kolejnej części wpisu o NumPy, gdzie zajmiemy się trochę bardziej skomplikowanymi zagadnieniami, jak np. fancy indexing czy broadcasting.

Podsumowanie

W tym wpisie skupiłem się na przedstawieniu bardzo ogólnego zarysu możliwości pakietu NumPy. Tematy tu omówione pozwolą zacząć z nim pracę, lecz zdecydowanie nie wyczerpują tematu. Skupiam się wyłącznie na najprostszych zagadnieniach oraz omawiam tylko nieliczne bardzo wielu możliwości pakietu. Z tego też względu powstanie kolejny wpis, będący kontynuacją i rozszerzeniem opisu podstaw NumPy.

Podstawy pakietu Numpy - część 1