Wizualizacja danych - podstawy pakietu Matplotlib
Wstęp
- 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
Pakiet Matplotlib
Teraz gdy podstawy NumPy i Pandas mamy już opanowane, pora zająć się kwestią wizualizacji danych. Nic tak nie pomaga w zrozumieniu struktury zbioru danych, jak zobrazowanie go przy użyciu odpowiedniego wykresu.
Jeśli mowa właśnie o wizualizacjach w kontekście data science i Pythona, to pierwszym i najczęściej używanym pakietem jest Matplotlib. Jest to bardzo obszerny i rozbudowany pakiet, dający niezmiernie dużo opcji edycji i dostosowywania wykresów. Jest on przy tym również dość prosty dla początkującego użytkownika (przynajmniej w do podstawowych zastosowań).
Cała biblioteka Matplotlib jest bardzo duża i zdecydowanie wykracza poza podstawowe zastosowania. W tym wpisie i ogólnie w kolejnych wpisach związanych z analizą i przetwarzaniem danych skupimy się na jednym jej module, a mianowicie pyplot. O pyplot można powiedzieć, że jest interfejsem do Matplotlib pozwalającym na generowanie wykresów z wewnątrz kodu Pythona. Sposób i wynik generowania wykresów przy pomocy pyplot jest bardzo zbliżony do tego znanego z MATLAB'a.
Jak w każdym z poprzednich wpisów, pracę musimy zacząć od przeprowadzenia niezbędnych importów.
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
Podobnie jak w wypadku Pandas i NumPy modułowi pyplot w procesie importu nadajemy rozpoznawalny i ogólnie stosowany alias, mianowicie plt. Dzięki temu nasze wywołania będą znacznie krótsze i czytelniejsze.
W tym miejscu również importujemy pakiety Pandas i NumPy. Przydadzą się one do generowanie danych, które potem będziemy przedstawiać na wykresach.
Pierwszy wykres - wykres liniowy
Najprostszym wykresem do narysowania przy użyciu pyplot jest wykres liniowy. Do jego stworzenia potrzebujemy jedynie dwie jednakowej długości listy z wartościami. Jedna odpowiadająca wartością na osi X, druga na osi Y. Zbiory wartości nie muszą być wcale listami w Pythonowym tego słowa znaczeniu. Mogą to być np. ndarray, pd.Series(), tuplę itp.
Takie dwa przygotowane zbiory danych przekazujemy do metody '''plt.plot()''', która tworzy na ich podstawie krzywe. Teraz jedynie wystarczy wywołać metodę '''plt.show()''', która pokaże w jupyter notebook'u nasz wygenerowany wykres.
plt.plot([1, 2, 3, 4], [3, 5, 2, 1])
plt.show()
Gdy wywołujemy metodę '''plt.plot()''' w tle poza samym wykresem tworzony jest również obiekt wykresu (figura), na którym krzywa ta rysowana. Możemy obiekt ten utworzyć również sami, przekazując przy tym zdefiniowane przez nas parametry. Podstawową zaletą tego jest możliwość zdefiniowania wielkości wykresu za pomocą parametru figsize, który przyjmuje tuplę z szerokością i wysokością w calach. Musimy jedynie pamiętać, aby '''plt.figure()''' wywołać przed '''plt.plot()''', aby krzywa, została dodana do wykresu.
plt.figure(figsize=(8, 3))
plt.plot([1, 2, 3, 4], [3, 5, 2, 1])
plt.title('Basic Line Plot', fontdict={'fontname': 'monospace', 'fontsize': 18})
plt.xlabel('X label')
plt.ylabel('Y label')
plt.show()
Moduł pyplot pozwala nam na dodawanie dodatkowych elementów do wykresu. Przy pomocy '''plt.title()''' zdefiniujemy tytuł wykresu. Pierwszym argumentem musi być string z tytułem. Definiując parametr fontdict i przypisując do niego słownik ze stylami, możemy zmienić sposób, w jaki wyświetlany jest tytuł.
Metody '''plt.xlabel()''' i '''plt.ylabel()''' umożliwiają nam zdefiniowanie nazw osi wykresu.
Wiele krzywych
Dotąd na naszym wykresie prezentowana była zawsze tylko jedna krzywa, nic nie stoi jednak na prrzeszkodzie, aby figura wykresu zawierała ich więcej. Wystarczy przed '''plt.show()''' wywołać więcej niż jeden raz metodę '''plt.plot()'''. Każde jej wywołanie spowoduje dodanie kolejnej krzywej do wykresu.
Matplotlib.pyplot jest na tyle sprytny, że automatycznie zmienia kolory kolejnym krzywym, dzięki czemu wykres wydaje się bardziej uporządkowany.
x = np.arange(0, 10)
plt.plot(x, x**2)
plt.plot(x, x*4)
plt.xticks(x)
plt.yticks(np.arange(0, 100, 10))
plt.show()
Metody '''plt.xticks()''' i '''plt.yticks()''' umożliwiają nam nadpisanie automatycznych znaczników osi. Wystarczy do nich przekazać obiekty, po których można iterować, zawierające interesujące nas wartości, przy których chcemy mieć znacznik. Dodam, że nie muszą one być równo od siebie oddalone.
Kolejnym bardzo przydatnym elementem wykresu, zwłaszcza w kontekście wielu krzywych znajdujących się na nim jest legenda. Do jej wyświetlenia służy metoda '''plt.legend()'''. Legenda automatycznie przyjmie optymalną pozycję, tak aby, jak najmniej zasłaniać nasz wykres, dzieje się tak, gdyż parametr odpowiadający za pozycję legendy loc, ma domyślnie wartość best. Możemy to jednak manualnie zmienić według uznania.
Problem w tym, pyplot nie wie, co ma wstawić do legendy. Każdej z krzywych musimy zdefiniować label, który będzie wyświetlany razem z fragmentem linii.
df = pd.DataFrame(np.random.randn(20, 4), columns=list('ABCD')).cumsum()
plt.plot(df['A'], 'r1:', label='A')
plt.plot(df['B'], 'g.--', label='B')
plt.legend()
plt.show()
Warto zauważyć, że na powyższym wykresie krzywe są przerywane, mają znaczniki i kolory odmienne od tych z wykresów wcześniejszych. pyplot pozwala nam edytować wygląd wykresów na bardzo wiele sposobów. Metoda '''plt.plot()''' pozwala nam przekazywać np. parametry takie jak: linewidth, linestyle,_ marker_, color itp.
Skrócone style linii
W przykładzie powyżej użyliśmy jednak wersji skróconej. Opierającej się na przekazaniu 3-znakowego ciągu znaków. Pierwszy znak to kolor, drugi typ markera a ostatni styl linii. Dzięki tak skróconemu zapisowi można bardzo szybko i prosto odróżnić od siebie nawet wiele krzywych.
Kolor Marker Styl Linii r czerwony . punkt - ciągła g zielony o okrąg -- kreski b niebieski ^ trójkąt : kropki y żółty * gwiazdki Pamiętać należy jedynie, że parametr należy przekazać po argumentach X i Y, a przed label. Ewentualnie za pomocą nazwanego parametru 'fmt'.
Wiele wykresów
Czasem dla lepszej czytelności wykresów i danych na nich przedstawionych dobrym pomysłem jest rozdzielenie wykresów. Możemy tego dokonać, używając metody '''plt.subplot()'''. Przyjmuje ona 3 liczny:
- ilość wykresów na figurze w pionie (wiersze)
- ilość wykresów w poziomie (kolumny)
- którym z kolei jest dany subplot
Liczby te można również zapisać bez przecinków, jako jedną 3-cyfrową liczbę.
Następnie wystarczy dodać za pomocą '''plt.plot()''' krzywe do wykresów. Każdy subplot może zawierać wiele krzywych oraz swój własny tytuł, czy opisy osi. Gdy wywołamy '''plt.subplot()''' wszystko, co zdefiniujemy pod wywołaniem, będzie należało do danego subplotu, aż do kolejnego wywołania '''plt.subplot()''' lub zakończenia generowanie figury przez '''plt.show()'''.
plt.subplot(1, 2, 1)
plt.plot(df['A'])
plt.title('Left plot')
plt.subplot(1, 2, 2)
plt.plot(df['B'])
plt.title('Right plot')
plt.suptitle('Horizontal subplots')
plt.show()
Metoda plt.suptitle() pozwala na dodanie tytułu, dla całej figury składającej się z wielu wykresów.
plt.subplot(2, 1, 1)
plt.plot(df['A'])
plt.subplot(2, 1, 2)
plt.plot(df['B'])
plt.suptitle('Vertical subplots')
plt.show()
Jak widzimy powyżej, dwa wykresy narysowane jeden nad drugim przedstawiają zbliżone krzywe, lecz położenie znaczników osi y różni się nieznacznie dla obu z nich. W niektórych przypadkach może to zaburzać zrozumienie danych przedstawionych na wykresach. Na szczęście pyplot pozwala nam szybko to naprawić, bez konieczności ustawiania manualnie, na sztywno dokładnego położenia znaczników.
Wystarczy, że oba subploty zapiszemy do zmiennych. Teraz w jednym z nich za pomocą parametru sharey przekażemy, z którym innym wykresem ma on dzielić oś y. W ten sposób oba wykresy będą miały taką samą oś y. Oczywiście '''plt.subplot()''' posiada analogiczny parametr sharex.
ax1 = plt.subplot(211)
plt.plot(df['A'])
ax2 = plt.subplot(212, sharey=ax1)
plt.plot(df['B'])
plt.suptitle('Vertical subplots')
plt.show()
Gdy jednak planujemy przedstawić za jednym razem więcej wykresów bądź mieć większą elastyczność w nadawaniu każdemu z nich oddzielnych parametrów warto skorzystać z metody '''plt.subplots()'''. Przyjmuje ona jako parametry ilość wierszy i kolumn tablicy wykresów oraz jej wymiary w calach. Zwraca ona natomiast obiekt figury i właśnie tablicę pustych wykresów - canvasów, na których możemy wyrysować potem krzywe, wybierając wykres po indeksie (dwuwymiarowym). W ten sam sposób można każdemu z wykresów z osobna przekazać tytuł czy opcje osi.
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8, 8))
ax[0, 0].plot(df['A'], 'r-')
ax[0, 1].plot(df['B'], 'yo--')
ax[1, 0].plot(df['C'], 'b*-.')
ax[1, 1].plot(df['D'], 'g^:')
ax[1, 1].set_title('D')
plt.savefig('example.png', dpi=200)
plt.show()
Na koniec warto jeszcze poruszyć kwestię zapisu wykresu do lokalnego pliku. Możemy tego dokonać metodą '''plt.savefig()'''. Jako argumenty przekazujemy ścieżkę do zapisu oraz opcjonalnie rozdzielczość podaną w punktach na cal.
Wykresy słupkowe
Kolejnym typem wykresów, które należy omówić po wykresach liniowych (krzywych), są wykresy słupkowe. Do przygotowania przykładowych wykresów potrzebować będziemy danych. Pomoże nam w tym NumPy, dzięki któremu utworzymy dwie jednowymiarowe tablice losowych liczb całkowitych, z określonych przedziałów. Do tego przyda się lista etykiet o tej samej długości.
labels = list('ABCD')
values = np.random.randint(10, 30, 4)
variance = np.random.randint(1, 4, 4)
Aby utworzyć wykres słupkowy, skorzystamy z metody '''plt.bar()'''. Przekazujemy do niej listę etykiet oraz listę wartości im odpowiadających. Obie listy muszą być równej długości. Zamiast etykiet możemy również przekazać wartości, będą one służyć wtedy za koordynaty, w których będzie się znajdować słupek na osi X.
Aby określić kolor słupków wykresu, wystarczy go przekazać parametrem color. Gdy przekażemy pojedynczą wartość, wszystkie słupki ją otrzymają. Aby natomiast nadać każdemu z nich różne kolory, musimy temu samemu kolorowi przekazać listę wartości je określających.
plt.bar(labels, values, color='purple')
plt.title('Bar chart')
plt.xlabel('X label')
plt.ylabel('Y label')
plt.show()
W prosty sposób możemy sprawić, aby słupki były ustawione w poziomie. Wystarczy zamiast metody '''plt.bar()''' użyć '''plt.barh()'''.
Jeśli posiadamy dane związane z błędem określenia wartości czy niepewnościami, możemy je przedstawić na wykresie w postaci errorbarów. Wystarczy w parametrze xerr (dla poziomych) lub yerr (dla pionowych) przekazać listę (lub obiekt listopodobny - tupla, pd.Series, ndarray) zawierającą wartości błędu. Zostaną one przedstawione na wykresie w postaci linii.
plt.barh(labels, values, xerr=variance, color='green')
plt.show()
Wykresy skumulowane
Matplotlib.pyplot pozwala nam niewielkim nakładem pracy przedstawić na wykresie słupkowym znacznie bardziej skomplikowane zależności. Załóżmy, że mamy dwa zbiory wartości, które chcemy porównać: values_A i values_B.
values_A = np.random.randint(10, 30, 4)
values_B = np.random.randint(10, 30, 4)
Aby za pomocą pyplot zbudować wykres skumulowany wystarczy do figury przekazać oba zbiory wartości, wywołują dwukrotnie '''plt.bar()''' z tymi samymi etykietami - labels. Musimy również przekazać wykresowi, który ma być wyżej od jakiej wartości bottom ma zacząć rysować słupki. Aby wykresy leżały dokładnie jeden na drugim, wystarczy w takim razie w parametrze bottom podać wartości słupków leżących niżej - ich wysokość.
Gdy na jednym wykresie pokazujemy więcej elementów, warto dodać legendę. Również w przypadku wykresów słupkowych, aby legenda zadziałała poza wywołaniem metody '''plt.legend()''' musimy elementom nadać parametry label.
plt.bar(labels, values_A, label='values_A')
plt.bar(labels, values_B, label='values_B', bottom=values_A)
plt.legend()
plt.show()
Wykresy grupowane
Troszkę więcej pracy mamy, gdy chcemy porównać słupki o tych samych etykietach, ale będące w różnych zbiorach, jeden obok drugiego. Będziemy musieli wyliczyć położenie w osi X sąsiadujących ze sobą słupków. Potrzebujemy do tego szerokości pojedynczego słupka: width oraz listy kolejnych liczb całkowitych, o tej samej długości co lista etykiet: index.
width oznacza jaką część całego miejsca w poziomie ma zająć pojedynczy słupek. Aby dla każdej etykiety zmieściły się 2 słupki (po jednym dla values_A i values_B), musimy dać Nie więcej niż 0.5. Wartość 0.4 spowoduje, że podwójne słupki dla różnych etykiet (np. między A i B) będą miały przerwę między sobą, co ułatwi odczyt.
index określa w których miejscach na osi X mają znajdować się podwójne słupki. Położenie każdego z nich wyliczamy, przesuwając je o połowę szerokości - width w lewo dla słupków niebieskich (values_A) i w prawo dla pomarańczowych (values_B).
Oprócz tego musimy do każdego wywołania metody '''plt.bar()''' przekazać trzeci parametr, określający jak szeroki ma być słupek, czyli nasze width.
width = 0.4
index = np.arange(len(labels))
plt.bar(index - width/2, values_A, width, label='values_A')
plt.bar(index + width/2, values_B, width, label='values_B')
plt.xticks(index, labels)
plt.legend()
plt.show()
Gdybyśmy tak pozostawili wykres, na osi X zobaczylibyśmy ciąg cyfr od 0 do 3 w miejscu znaczników osi, gdyż zamiast labels użyliśmy indeksów o tej samej długości. Aby to zmienić, wystarczy wywołać metodę '''plt.xticks()''' i przekazać jej naszą listę indeksów i odpowiadających im etykiet. Metoda zadziała tak, że znacznikowi o wartości zgodnej z pierwszym elementem listy indeksów przypisze wartość pierwszego elementu listy etykiet, i tak dalej.
Wykresy kołowe
Bardzo prostym typem wykresów, które możemy zbudować na podstawie wartości i odpowiadających im etykiet, które wygenerowaliśmy dla prostych wykresów słupkowych, są wykresy kołowe. Do narysowania najprostszego wykresu wystarczy do metody '''plt.pie()''' przekazać podobnie jak w wykresach słupkowych listy etykiet i wartości im odpowiadających.
plt.pie(values, labels=labels)
plt.show()
W przypadku wykresów kołowych nic nam nie da przekazanie jednego koloru wszystkim elementom wykresu. Stąd też, aby nadać własne kolory, musimy w parametrze colors przekazać listę z kolorami o tej samej długości co listy etykiet i wartości. Poszczególne kolory mogą być stringami zawierającymi wartości HEX lub nazwami kolorów.
colors = ['#fcba03', '#00c3ff', '#8a134e', '#aee33b']
plt.pie(values, labels=labels, colors=colors)
plt.show()
Przydatną właściwością wykresów kołowych w matplotlib jest możliwość rozstrzelenia ich elementów dla lepszej czytelności. Aby uzyskać ten efekt, wystarczy do parametru explode przekazać listę tej samej długości co lista wartości, w której zdefiniowane są, jak bardzo poszczególne elementy mają być jakby wysunięte z wykresu. 0 oznacza, że nie ma wysunięcia, a 1, że element jest wysunięty o wartość promienia wykresu na zewnątrz.
explode = [0, 0.3, 0.2, 0]
plt.pie(values, explode=explode, labels=labels, autopct='%.2f')
plt.show()
Parametr autopct mówi metodzie, aby wyświetliła na elementach, jakim są procentem całości wykresu. String przekazany w tym parametrze określa, jak ma być sformatowany wynik. Zapis '%.2f' mówi, że chcemy procenty pokazać jako liczby zmiennoprzecinkowe, z dokładnością do dwóch miejsc po przecinku.
Wykres pudełkowy
Gdy już umiemy tworzyć najbardziej podstawowe wykresy, pora skupić się trochę na typach wykresów stosowanych w zagadnieniach statystycznych. Pierwszym z nich będą wykresy pudełkowe, pokazujące w sposób obrazowy podstawowe metryki statystyczne zbiorów danych.
Metoda '''plt.boxplot()''' bo o niej mowa, przyjmuję listę zbiorów, które ma zobrazować. Dla każdego przekazanego zbioru otrzymamy oddzielny wykres pudełkowy. Jako zbiory możemy przekazywać obiekty listopodobne, czyli poza listami z wartościami numerycznymi mogą to być również ps.Series, czy ndarray.
Aby dodać etykiety poszczególnym pudełkom, musimy w parametrze labels przekazać listę odpowiadających wykresom etykiet.
plt.boxplot([values_A, values_B], labels=['values_A', 'values_B'])
plt.show()
W dużym skrócie wykres pudełkowy przedstawia jakie wartości mają poszczególne metryki statystyczne. Pudełko określa zakres (różnicę) między trzecim a pierwszym kwartylem (Q3 - Q1), a kreska w środku pudełka obrazuje medianę zbioru. Wąsy wystające poza pudełko odzwierciedlają wartości wychodzące o 1.5IQR czyli o 1.5 razy wysokość pudełka (1.5 * (Q3 - Q1)). Wszystkie wartości wychodzące poza zakres wąsów określa się jako wartości odstające - outliers.
O tych i innych wykresach statystycznych powiemy sobie więcej w innym wpisie, gdzie zajmiemy się pakietem seaborn.
Histogramy
Kolejnym wykresem obrazującym rozkład statystyczny zbioru jest histogram. Jest to wykres, dzięki któremu pokazujemy, jak rozkłada się częstość występowania wartości w zbiorze podzielonym na zdefiniowane przedziały. Histogramy tworzymy za pomocą metody '''plt.hist()''' do której przekazujemy nasz zbiór wartości. W tym wypadku tysiąca przypadkowych wartości z przedziału od około -30 do około 30.
Domyślnie metoda dzieli zakres wartości na 10 równych części nazywanych binami (bins). Każdy słupek odzwierciedla, ile elementów z zadanego zbioru mieści się w przedziale określającym jeden z binów.
x = np.random.randn(1000) * 10
plt.hist(x)
plt.title('Histogram')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()
Możemy zmienić domyślny podział binów, na nasz własny. Musimy wtedy w parametrze bins przekazać obiekt listopodobny, który zawiera początki kolejnych binów. Świetnie nadają się do tego metody '''np.arange()''' lub '''np.linspace()'''.
Prostą sztuczką pozwalającą rozdzielić sąsiednie słupki jest przesunięcie początku każdego binu i jednoczesne zmniejszenie jego szerokości o wartość dwukrotnie większą niż przesunięcie. Spowoduje to, że słupki nadal będą w środku przedziałów i będą od siebie nieznacznie oddalone.
bins = np.arange(-30, 40, 10)
plt.hist(x, bins=bins + 1, width=8)
plt.xticks(bins)
plt.show()
Niektóre właściwości rozkładu wartości zmiennych łatwiej jest interpretować na podstawie tak zwanych histogramów skumulowanych. Aby taki wytworzyć, wystarczy do '''plt.hist()''' przekazać dodatkowy parametr cumulative=True. Również przy pomocy jednego parametru: histtype możemy zmienić typ wyświetlania histogramu. Po dokładniejsze informacje odsyłam do dokumentacji.
bins = np.arange(-30, 40, 5)
plt.hist(x, bins=bins, cumulative=True, histtype='step')
plt.xticks(bins)
plt.show()
Wykresy punktowe - scatter plots
Ostatnimi wykresami, które należy omówić we wpisie o podstawach Matplotlib i pyplot są wykresy punktowe. Świetnie nadają się do przedstawienia zależności między dwoma kolumnami w zbiorze danych, poszukiwania pewnych wzorców, czy obrazowania wartości odstających od reszty.
Aby pokazać, jak możemy wykorzystać wykresy punktowe, musimy utworzyć dane do przedstawienia. Niech będą to trzy wektory wartości przypadkowych, o równej długości.
x_values = np.random.randint(20, 80, 20)
y_values = np.random.randint(30, 120, 20)
y2_values = np.random.randint(30, 120, 20)
Podstawowy wykres punktowy narysujemy, przekazując metodzie '''plt.scatter()''' dwa jednakowodługie wektory wartości, o których możemy myśleć jak o zbiorach wartości na osiach X i Y. Nad zakresami obu osi możemy zapanować, przekazują wartości minimalne i maksymalne do metod '''plt.xlim()''' i '''plt.ylim()''' odpowiednio dla osi X i Y.
plt.scatter(x_values, y_values)
plt.xlim(0, 100)
plt.ylim(0, 150)
plt.title('Scatter plot')
plt.show()
Podobnie jak w przypadku innych typów wykresów, również w przypadku wykresów punktowych możemy na jednej figurze przekazać kilka różnych zależności. Każdą kolejną dodajemy fo figury wykresu, wywołując kolejną metodę '''plt.scatter()''' z nowym zestawem wartości x i y.
Każdy kolejny zestaw wartości XY dostanie, dla odróżnienia, nowe kolory znaczników. Jednak za pomocą parametrów c (color) i marker możemy ostylować kolor i kształt markerów według własnego uznania. Oczywiście, gdy dodamy do figury etykiety (label) poszczególnym wykresom oraz legendę, kolory i style markerów również zostaną na niej odzwierciedlone.
Przydatnymi dodatkami do wykresu podnoszącym interpretowalność są linie pomocnicze, czyli cienkie przerywane linie na wykresie rozpoczynające sie w znacznikach osi. Dodajemy je do figury za pomocą metody '''plt.grid()'''.
plt.scatter(x_values, y_values, c='#8a134e', marker='+')
plt.scatter(x_values, y2_values, c='#00c3ff', marker='*')
plt.xlim(0, 100)
plt.ylim(0, 150)
plt.grid()
plt.title('Multi scatter plot')
plt.show()
Ostatnią ciekawą funkcjonalnością wykresów punktowych, którą chciałbym opisać, jest możliwość nadawania płaskiemu wykresowi 2D iluzorycznego trzeciego wymiaru. Możemy to osiągnąć poprzez zmianę wielkości poszczególnych markerów zgodnie z trzecim wektorem danych. Gdy przekażemy do parametru s metody '''plt.scatter()''' wektor tej samej długości co x i y, każdy marker będzie miał wielkość określona odpowiadającą wartością tego wektora (powiedzmy z). Parametr alpha określa przezroczystość markerów, dla lepszej widoczności.
plt.scatter(x_values, y_values, s=y2_values * 2, alpha=0.5)
plt.xlim(0, 100)
plt.ylim(0, 150)
plt.grid()
plt.title('Scatter plot with area & alpha')
plt.show()
Podsumowanie
Jak widać w przypadku pakietu Matplotlib, a dokładniej jego modułu pyplot całe podstawy udało się zamknąć w jednym, choć dość długim wpisie. Omówiliśmy wszystkie podstawowe typy wykresów włącznie z ich udziwnieniami, które to jednak mogą się przydać w naszej dalszej pracy. Nie skupiałem się bardzo na upiększaniu wykresów, wolałem opisać, jak sprawić, żeby w możliwie prosty sposób sprawić, aby wykres pokazywał wszystko to co niezbędne, w dość minimalistycznej formie.
Nie jest to ostatni wpis na temat wizualizacji danych związanej z data science. Planuję w przyszłości zająć się również drugą często używaną biblioteką - seaborn. Jest ona bardziej nastawiona na wizualizacje statystyczne, ale równie często używana w zagadnieniach związanych z analizą danych, co Matplotlib.