Zrozumienie poruszonych aspektów pozwala odpowiedzieć na istotne pytania. Jakie struktury wykorzystywać, by uniknąć krytycznych błędów? Jak zwiększyć efektywność pracy w Pythonie i zadbać o czysty kod? Jak asystenci AI wspierają codzienną pracę programistów?

Trochę historii na początek – przykłady problemów z liczbami zmiennoprzecinkowymi

Błąd systemu obrony przeciwrakietowej Patriot 

Podczas wojny w Zatoce Perskiej w 1991 roku system nie zadziałał prawidłowo i nie przechwycił rakiety Scud, która uderzyła w koszary wojskowe w Dhahran w Arabii Saudyjskiej, zabijając 28 osób. Przyczyną był błąd w obliczeniach czasu. System śledził czas za pomocą liczby całkowitej reprezentującej liczbę taktów zegara, przy czym każdy takt odpowiadał za około 0.1 sekundy. Aby obliczyć dokładny czas, liczba całkowita była mnożona przez 0.1, która w pamięci była reprezentowana jako liczba przybliżona ze względu na ograniczenia formatu IEEE 754. Z każdym kolejnym cyklem zegara błąd się kumulował, przez aż 100 godzin od uruchomienia systemu, ostatecznie narastając do około 0.34 sekundy. Ta różnica spowodowała, że system obliczył błędne położenie rakiety Scud i nie zadziałał na czas. Po incydencie wprowadzono aktualizację oprogramowania, która resetowała zegar systemowy częściej, zmniejszając wpływ kumulacji błędów. Ta tragiczna w skutkach historia amerykańskiego systemu obrony rakietowej Patriot to jeden z klasycznych przykładów błędu wynikającego z ograniczeń liczb zmiennoprzecinkowych. Ta historia pokazuje, że w tak istotnych obliczeniach należy unikać stosowania przybliżeń i używać precyzyjniejszych typów danych.  

Wybory parlamentarne w Schleswig-Holstein 

Innym przykładem są wybory parlamentarne z 1992 r. w niemieckim Schleswig-Holstein. W tym, jak i w większości niemieckich landów, obowiązuje system proporcjonalny, w którym partie muszą uzyskać co najmniej 5% głosów, aby otrzymać mandaty w parlamencie. Wyniki wyborów były prezentowane w procentach, a zaokrąglenia miały miejsce na różnych etapach obliczeń. Partia Zielonych uzyskała 4.97%, ale na etapie prezentacji wyników wartość została zaokrąglona do 5%, a więc próg został spełniony, co całkowicie zmieniło rozkład mandatów w parlamencie. Doprowadziło to do wielu kontrowersji i publicznej debaty, jednak mimo to wyniki zostały uznane za wiążące. W systemie nie przewidziano procedury na wypadek błędu zaokrąglenia.  

Float – liczby zmiennoprzecinkowe w Pythonie

W tym kontekście bardzo ciekawą prelekcją z mojej perspektywy była ta o typie Float, czyli liczbach zmiennoprzecinkowych w Pythonie.  

Liczby te można tworzyć na różne sposoby, poprzez dosłowne przekazanie liczby, czyli np. 1.0, używając klasy tj. float(1) lub poprzez działania matematyczne takie jak 1/1. 

Standard IEEE 754 binary64 

Z dokumentacji Pythona dowiadujemy się, że we wszystkich znanych implementacjach interpretera Pythona float zdefiniowany jest jako double. Bardziej szczegółowo typ ten jest opisany według standardu IEEE 754 binary64 i wygląda to następująco: 

Patrząc po kolei od lewej: 

• 1 bit jest poświęcony na znak (liczba dodatnia lub ujemna). 
• 11 bitów wyraża wykładnik potęgowy. 
• 52 bity wyrażają ułamek. 

A wszystko to można przedstawić za pomocą poniższego wzoru: 

(-1)^sign x 2^(exp-1023) x 1.fraction 

Według omówionego standardu poniżej kilka przykładów reprezentacji binarnej: 

a) Liczba 0.0 

0 (sign) 00000000000 (exponent)

(0).0000000000000000000000000000000000000000000000000000 (fraction) 

b) Liczba 1.0 = 1 x 1.0 = 2^0 x 1.0 = 2^(1024-1024) x 1.0 

0 (sign) 01111111111 (exponent)

(1).0000000000000000000000000000000000000000000000000000 (fraction) 

c) Liczba 3.0 = 2 x 1.5 = 2^1 x 1.5 =2^(1025-1024) x 1.5 

0 (sign) 10000000000 (exponent)

(1).1000000000000000000000000000000000000000000000000000 (fraction) 

Precyzja typu Float 

Powyższe przykłady są dość proste z punktu widzenia reprezentacji binarnej, jednak problem pojawia się przy liczbach niecałkowitych, ponieważ nie zawsze jesteśmy w stanie zapisać je w pamięci z pełną precyzją. Można to zaobserwować, używając w Pythonie metody as_integer_ratio(), aby sprawdzić, jakie liczby są użyte do dzielenia, by uzyskać oczekiwany wynik. Jak widać na poniższym przykładzie, dla liczby 0.1 nie ma liczb 1 i 10, jak byśmy tego oczekiwali, tylko 3602879701896397 i 36028797018963968. Są to liczby, które dają najbardziej precyzyjne przybliżenie do 0.1 i możliwe do zapisu w pamięci według omawianego standardu. Natomiast to, że wywołując print() na obliczeniu 1/10 otrzymujemy 0.1, wynika wyłącznie z tego, że print() automatycznie zaokrągla nam do najkrótszego zapisu dziesiętnego, który się mieści w ramach ostatniego bitu precyzji.  

Inną przydatną metodą w Pythonie, pozwalającą zyskać więcej informacji na temat floatów, jest sys.float_info. Dzięki niej możemy się dowiedzieć, że float pozwala na przechowywanie do 15 cyfr znaczących (dodatkowo ewentualnie znak plus-minus i/lub przecinek).  

To wszystko może sprawić, że zaczniemy się zastanawiać nad tym, jak dużo ucieka nam precyzji podczas używania typu float. Do tego przydatna jest metoda math.ulp() (czyli Unit in the Last Place), co w praktyce zwraca nam różnicę pomiędzy podaną liczbą a następną, którą jesteśmy w stanie zapisać w tym formacie w pamięci. W przypadku małych liczb te różnice są bardzo marginalne, jednak przy takiej liczbie jak 2^52 ta różnica wynosi już równo 1.0. Oznacza to, że właściwie od tej liczby wzwyż całkowicie tracimy części ułamkowe. Idąc dalej, przy 2^53 różnica ta wynosi już 2.0. Zatem ważnym wnioskiem jest, by tak dużych liczb, nawet całkowitych, nie przechowywać jako float, ponieważ tylko liczby parzyste w tym przypadku zachowałyby swoją precyzję. 

Symbole specjalne 

W standardzie IEEE 754 przewidziano również miejsce dla specjalnych symboli. Jeśli 11-bitowa część exponent jest cała wypełniona jedynkami, a 52-bitowa część wyrażająca ułamek wypełniona zerami, to mamy do czynienia z reprezentacją binarną nieskończoności. Zapełniając zerem bit odpowiedzialny za znak otrzymujemy plus nieskończoność, a jedynką minus nieskończoność. 

Z kolei mając również 11-bitową część exponent wypełnioną jedynkami, ale także część wyrażającą ułamek wypełnioną jedynkami, otrzymujemy symbol NaN (Not a Number). Wszelkie operacje porównujące takie jak =, >, < z udziałem NaN zwracają False, co może być problematyczne w różnych okolicznościach. Zwłaszcza kiedy użytkownik ma braki w danych i sądzi, że porównywana jest faktyczna liczba, a nie pusta reprezentacja w postaci NaN.  

Zaokrąglenia 

Co jednak, jeśli nie jest potrzebna nam aż taka dokładność i chcemy uprościć jakieś obliczenia? Odpowiedzią są zaokrąglenia i należy wiedzieć, że uzyskać je można na różne sposoby. Co istotne, nie różnią się jedynie nazwy funkcji, ale ich implementacje mają odrębne podejścia. W prezentacji podczas Python Summit 2024 przedstawiono następujące metody: 

1. Funkcja round() – zaokrągla zadaną liczbę do najbliższej liczby z określoną liczbą miejsc po przecinku, domyślnie do liczby całkowitej. Natomiast szczególnym przypadkiem jest sytuacja, gdy liczba jest równo w połowie i w obie strony jest taka sama odległość. Wtedy najmniej znacząca cyfra zaokrąglana jest do liczby parzystej, co według statystyków minimalizuje skumulowany błąd podczas wykonywania wielu operacji zaokrąglania. Czyli przykładowo zarówno 1.5, jak i 2.5 zostaną zaokrąglone do 2, jeśli interesuje nas liczba całkowita. Co ciekawe, w przypadku takich liczb jak 1.15 i 1.25 również obie powinny zostać zaokrąglone do 1.2, gdyby chcieć zachować dokładność do jednego miejsca po przecinku. Jednak tylko 1.25 zwróci poprawnie 1.2, a dla 1.15 zostanie zwrócone 1.1. Wynika to właśnie z tego, że liczby 1.15 nie da się precyzyjnie przechować w pamięci według standardu IEEE 754, a będzie to 1.1499999999999999. Czyli nie jest to de facto równo w połowie, a więc zaokrągli w dół do 1.1. 

2. int() lub math.trunc() – co prawda nie są to funkcje zaokrąglające, tylko obcinające liczbę, ale ich efekt działa tak, jakbyśmy zaokrąglali liczbę w kierunku 0. Czyli przykładowo 1.9 zostanie ucięte (zaokrąglone) do 1, natomiast -1.9 zostanie sprowadzone do -1.  

3. math.floor() lub x // 1 – pierwsza z nich po prostu zaokrągla w dół, w kierunku –nieskończoności. Natomiast druga to dzielenie bez reszty, przy czym dzieląc przez jeden, uzyskamy ten sam efekt co w przypadku pierwszej funkcji. Przykładowo dla obu z nich -1.9 zostanie zaokrąglone do -2, a 1.9 do 1. 

4. math.ceil() – zaokrąglanie w górę, w kierunku + nieskończoności. Używając tego samego przykładu -1.9 zostanie zaokrąglone do -1, natomiast 1.9 zaokrągli do 2. 

Developer Experience – jak mierzyć efektywność developera?

W przeszłości na różne sposoby próbowano mierzyć efektywność developerów. Jedną z bardziej popularnych, a zarazem nietrafionych metod, było mierzenie efektywności poprzez liczbę napisanych linii kodu. Podczas drugiej z wspomnianych prezentacji przytoczono koncepcję, która nie tyle pozwala na mierzenie produktywności, co pomaga zadbać o efektywne środowisko pracy. Mowa tutaj o DevEX (Developer Experience), które wyróżnia 3 filary: 

1. Stan przepływu (Flow state) – z punktu widzenia developera jest to stan głębokiego skupienia, w którym jesteśmy w stanie spokojnie pracować. Jeśli cele nie są jasno doprecyzowane, może wystąpić konieczność przerwania zadania, by ustalić nieścisłości. 
2. Pętle zwrotne (Feedback loops) – oznacza, ile czasu mija, zanim developer się dowie, że kod nie działa. W przypadku testów jednostkowych ten feedback jest bardzo szybki, ale w przypadku code review na feedback trzeba zaczekać dłużej. 
3. Ładunek kognitywny (Cognitive load) – oznacza wysiłek umysłowy wymagany do skutecznego pisania kodu. Jeśli programista spotyka się z projektem o innej strukturze niż zwykle albo nie ma do dyspozycji dokumentacji, do której zawsze miał dostęp, ten ładunek będzie wyższy. 

Narzędzia do efektywnej pracy w Pythonie

Wielu programistów rozpoczyna przygodę z Pythonem, gdyż zachęca ich intuicyjna składnia i wszechstronność zastosowań tego języka w analizie danych. W miarę rozwoju umiejętności w naturalny sposób poszukujemy narzędzi pozwalających zwiększyć efektywność pracy i ułatwiających życie. Podczas kolejnej prezentacji, w której miałem okazję brać udział w trakcie Python Summit 2024, zostały omówione takie narzędzia: 

1. Formatery  

Formatowanie kodu to bardzo istotny aspekt, ponieważ to od tego głównie będzie zależało, czy programiście wygodnie się czyta oraz pisze kod. Jednak każdy z nas może mieć nieco inne preferencje, przyzwyczajenia, dlatego najlepiej, aby został przyjęty jeden ściśle określony sposób formatowania. Zaleca się korzystanie ze standardu PEP 8. Jest to dość długi dokument, dlatego dbanie samodzielnie o każdy szczegół mogłoby być bardzo czasochłonne – ładunek kognitywny rośnie. Dodatkowo podczas code review to byłaby rzecz, na którą trzeba zwracać uwagę, zatem przekłada się to na dodatkowy czas poświęcony po stronie zespołu, a i pętla zwrotna się wydłuża. I tutaj z pomocą przychodzą formatery kodu, które mogą wykonać całą pracę za nas. Przykładowe formatery kodu w Pythonie to: black, isort, ruff, yapf. 

2. Lintery 

Są to narzędzia do statycznej analizy kodu, dzięki którym możemy dowiedzieć się o niektórych błędach jeszcze przed uruchomieniem kodu. Ponadto lintery są w stanie naprawiać za nas takie błędy jak np. literówki powstałe poprzez użycie nieistniejącej zmiennej. Inne kwestie, które mogą być sprawdzane automatycznie, to ilość znaków w każdej linii, długość nazw funkcji, zmiennych, ilość argumentów do funkcji itp. Przykłady linterów w Pythonie to: pylint, flake8, ruff. 
 

3. Adnotacje typów i type checkery 

W kwestii typów zmiennych Python jest bardzo liberalny, ponieważ mamy tu do czynienia z typowaniem dynamicznym. Mimo to określanie typów, jakie przewidujemy dla danych zmiennych, jest postrzegane jako dobra praktyka w Pythonie. Jest to funkcja, która została wprowadzona od wersji Pythona 3.5. Należy mieć na uwadze, że adnotacje typów są jedynie komentarzem i nie są uwzględniane przez program, o ile nie ma zewnętrznej biblioteki, która by je interpretowała. Używając jednak PyCharma, jednego z najpopularniejszych IDE dla Pythona, możemy odnieść korzyści z adnotacji typów natychmiastowo. PyCharm posiada wbudowany type checker, dzięki czemu będziemy widzieć różne podpowiedzi dotyczące typów. Inne popularne zewnętrzne type checkery to: mypy, pyright czy też pyre. 

Rekomendacja dotycząca omówionych narzędzi bardzo przypadła mi do gustu. Według prelegentów Python Summit 2024 dobrym wyborem będzie ruff, ponieważ świetnie sprawdza się zarówno jako formater, jak i linter. Zastępuje inne narzędzia oraz jest bardzo szybki. Dodatkowym argumentem, by się bliżej przyjrzeć tej bibliotece, jest to, że w planach jest rozszerzenie jej funkcjonalności również o type checker. Jednak na ten moment należy korzystać ze sprawdzonych i popularnych narzędzi do sprawdzania typów, takich jak mypy oraz pyright.  

Asystenci AI jako wsparcie produktywnej pracy

Na koniec temat, bez którego trudno obecnie wyobrazić sobie przyszłość programowania – mianowicie narzędzia sztucznej inteligencji. Poza wspomnianymi tradycyjnymi narzędziami do usprawniania pracy w Pythonie podczas konferencji w prezentacjach osobną część poświęcono nowoczesnym podejściom do tworzenia oprogramowania wykorzystującym asystentów AI.  

O ile obecnie raczej nie ma co liczyć na to, że napiszą za nas cały program, o tyle mogą świetnie się sprawdzić jako usprawnienie pracy. Zainstalowanie takiej wtyczki jak chociażby Copilot może przyspieszyć proste operacje czy też tworzenie komentarzy dzięki trafnym podpowiedziom.  

Jeśli nie pamiętamy składni, argumentów biblioteki etc., sprawdzanie dokumentacji może okazać się już zbędne. Asystenci AI mogą również przyspieszyć pisanie prostych testów jednostkowych. Warto jednak najpierw napisać kilka z nich samodzielnie, by asystent mógł lepiej rozpoznać poprawny wzór. 

Poniżej kilka przykładów najbardziej popularnych narzędzi programistycznych.   

• GitHub Copilot – narzędzie analizuje kontekst kodu i pozwala zautomatyzować, a tym samym przyspieszyć uzupełnianie fragmentów kodu. Przydatny w tworzeniu i przeglądzie dokumentacji oraz wyszukiwaniu konkretnych rozwiązań. 
• Supermaven – sugeruje zależności i poprawki w kodzie, eliminując błędy i optymalizując wydajność aplikacji. Narzędzie może zasugerować użycie najlepszej biblioteki pod kątem danego projektu, co skraca czas analizy i przyspiesza proces wdrażania nowych rozwiązań. 
• Cursor AI – usprawnia pracę programistów Python dzięki inteligentnemu autouzupełnianiu, generowaniu kodu na podstawie języka naturalnego oraz możliwości szybkiego refactoringu. 
• Tabnine – pozwala uzupełniać kod w czasie rzeczywistym, co zwiększa produktywność i pomaga unikać błędów składniowych, a także eliminuje powtarzalność zadań związanych z pisaniem kodu. 
• Sourcegraph Cody – sprawdza się świetnie w zaawansowanym przeszukiwaniu kodu. Pozwala na zrozumienie zależności w projektach oraz – dzięki kontekstowej analizie całej bazy kodu – na szybkie odnajdywanie i poprawianie błędów. 

AI w programowaniu | bezpłatny e-book

Zautomatyzuj kodowanie z AI! Pobierz darmowy e-book i odkryj nowe możliwości

Pobierz teraz!

Podsumowanie

Mnogość dostępnych technologii w świecie IT potrafi przyprawić o zawrót głowy. Samo określenie roli w projekcie IT jeszcze nie determinuje wyboru narzędzi, z których będziemy korzystać. Decydować o tym będą w głównej mierze wymagania systemu. Czy powinien być nastawiony na wydajne przetwarzanie dużych ilości danych, czy może bardziej istotna jest prostota w implementacji i szybkie wdrożenie rozwiązania kosztem niższej wydajności? Odpowiedzenie sobie na te pytania czasem nie wystarczy, ponieważ bywa, że kilka technologii spełnia wszystkie wymagania i wybór sprowadza się do względów czysto estetycznych i preferencji osobistych.  

Na szczęście są społeczności i organizacje, które skupiają ludzi zainteresowanych określoną tematyką i pomagają odnaleźć się w gąszczu wiedzy oraz poszerzać horyzonty, by być na bieżąco. Dla osób związanych zawodowo z językiem programowania Python takim miejscem jest właśnie konferencja Python Summit. Prelekcje dostępne w trakcie Python Summit 2024 i zagadnienia, które omówiłem, stanowią tylko mały wycinek wiedzy, jaki można było wynieść z tego spotkania. Zapewniam, że każdy znalazłby coś dla siebie, nawet jeśli wybrane przeze mnie tematy nie są w centrum zainteresowania danego programisty. 

Przeczytaj także nasze artykuły dotyczące bibliotek Python:  

• NumPy 
• Matplotlib 
• Pandas 

Biblioteki Python: Pandas. Dlaczego warto ją poznać? 

Biblioteka została stworzona, aby ułatwić pracę z różnego rodzaju danymi, które nie zawsze są kompletne lub wymagają odpowiedniej obróbki w celu ich dalszego przetwarzania. Pandas dostarcza elastyczne i łatwe w użyciu struktury danych i narzędzia (chociaż nie zawsze wydajne, w dalszej części zdradzę, w jaki sposób sobie z tym poradzić). Obok takich bibliotek jak NumPy, Matplotlib, Seaborn czy Scikit-Learn przez wiele lat, biblioteka Pandas zapracowała na popularność i uznanie wśród kadry akademickiej, analityków, inżynierów i pasjonatów zainteresowanych pracą z danymi. 

Jest to idealne narzędzie do zarządzania danymi i analizowania ich (z pomocą dodatkowych bibliotek) w małych i średnich zbiorach. W przypadku zbiorów rozległych, popularnych w obszarze związanym z Big Data, przetwarzanie jest możliwe, ale wraz ze wzrostem ilości danych, rośnie prawdopodobieństwo problemów z pamięcią i wydajnością. 

Kiedy sprawdzi się biblioteka Pandas? 

Biblioteka Pandas jest dobrze przystosowana do pracy z wykorzystaniem różnych typów i źródeł danych: 

• Tablicowe dane z kolumnami różnego typu (np. Excel, SQL) 
• Szeregi czasowe (time-series) 
• Dane z etykietami wierszy i kolumn (labeled data) 

Przykładowe zastosowania biblioteki Pandas

Oto kilka przykładów zastosowań biblioteki Pandas: 

• Wczytywanie różnych formatów danych (CSV, Excel, SQL, pliki płaskie itd.) 
• Filtrowanie, sortowanie i inne operacje z danymi 
• Czyszczenie danych (usuwanie wartości NaN – Not a Number), uśrednianie, zastępowanie wartości itp.) 
• Szybkie i efektywne obliczanie statystyk i przeprowadzanie operacji na danych 
• Wizualizacja danych za pomocą wykresów 

Zanim zaczniemy korzystać z biblioteki Pandas, upewnijmy się, że jest ona zainstalowana w środowisku Python. 

Jak zainstalować Pandas? 

Instalacja Pandas jest bardzo prosta i może zostać wykonana za pomocą narzędzia pip, które jest domyślnym menedżerem pakietów Python. Zakładam, że Python jest już zainstalowany na twoim komputerze, a jeżeli nie – tutaj jest instrukcja, jak to zrobić.  

Następnie wystarczy otworzyć terminal i wpisać poniższą komendę: 

pip install pandas

Możliwe, że będzie wymagane nadanie uprawnień do wykonania tej komendy (np. przy użyciu sudo na systemach Unixowych lub uruchamiając terminal z prawami administratora w systemie Windows), a w przypadku korzystania z konkretnego wirtualnego środowiska Python (np. venv lub conda), konieczne będzie aktywowanie tego środowiska przed zainstalowaniem pakietu. Więcej o wirtualnych środowiskach przeczytasz w dokumentacji.

Jeżeli używasz Anacondy, możesz zainstalować Pandas za pomocą polecenia: 

conda install pandas

Jak zaimportować Pandas do swojego projektu? 

Gdy biblioteka Pandas jest już zainstalowana, możemy zacząć z niej korzystać. Pierwszym krokiem jest zaimportowanie biblioteki do naszego skryptu lub projektu. Import biblioteki Pandas nie różni się niczym od jakiejkolwiek innej biblioteki w Pythonie. 

Możemy to zrobić za pomocą poniższego kodu: 

import pandas as pd

W Pythonie Pandas zazwyczaj importuje się pod aliasem ‘pd’, który jest krótkim i powszechnie przyjętym skrótem. Teraz, kiedy chcemy użyć funkcji z biblioteki Pandas, zamiast wpisywać pełne słowo „pandas”, używamy skrótu „pd”. Analogicznie sytuacja wygląda w przypadku biblioteki NumPy (‘np’), o której pisałem w jednym z poprzednich artykułów.  

Przykładowo, jeśli chcielibyśmy stworzyć DataFrame (jedną z kluczowych struktur danych w Pandas), kod wyglądałby następująco: 

import pandas as pd

data = {

    'column_1': [3, 2, 0, 1],

    'column_2': [0, 3, 7, 2]

}

example_df = pd.DataFrame(data)

print(example_df)

Jak widać na powyższym przykładzie, użyłem klasy DataFrame, podstawowej struktury, którą udostępnia nam Pandas. W kolejnym rozdziale omówimy inne dwie podstawowe struktury danych – Series i DataFrame. 

Ramki danych i serie – Pandas DataFrame i Series 

Głównym celem biblioteki Pandas jest ułatwienie pracy z danymi, dlatego Pandas wprowadza dwie struktury danych: Series i DataFrame. Zrozumienie tych struktur jest kluczowe do efektywnego korzystania z tej biblioteki. 

Series 

Series to jednowymiarowa struktura danych, a właściwie tablicy (ndarray), podobna do listy lub kolumny w tabeli. Każdy element (np. liczby całkowite, listy, obiekty, tuple) w Series ma przypisany identyfikator, który nazywany jest indeksem. Series przechowuje dane jednego typu. 

Przykładowo, stworzenie Series, który zawiera listę elementów, może wyglądać tak: 

import pandas as pd

vals_sr = pd.Series(["Val_1", "Val_2", "Val_3", "Val_4", "Val_5"])

print(vals_sr)

Jeżeli chodzi o indeks, to domyślnie są to liczby całkowite (integer), zaczynając od zera. Indeks można zmienić, np. nadając etykiety. W takim przypadku należy rozszerzyć nasz kod odpowiedzialny za tworzenie Series. Służy do tego parametr index, a kod wygląda następująco: 

import pandas as pd

vals_sr = pd.Series(["Val_1", "Val_2", "Val_3", "Val_4", "Val_5"], index=["A", "B", "C", "D", "E"])

print(vals_sr)

Warto pamiętać, że liczba “etykiet” powinna odpowiadać liczbie elementów w Series. W przeciwnym razie Python interpreter zwróci nam błąd (ValueError). Jeżeli nie chcesz wyświetlać całego Series, a jedynie sprawdzić, jakie indeksy zostały nadane lub wyświetlić tylko wartości bez indeksów, możesz skorzystać z następującego fragmentu kodu:

import pandas as pd

vals_sr = pd.Series(["Val_1", "Val_2", "Val_3", "Val_4", "Val_5"], index=["A", "B", "C", "D", "E"])

print(vals_sr)

print(vals_sr.index) # -- zwraca obiekty typu Index

print(vals_sr.values) # -- zwraca obiekt typu ndarray

DataFrame

DataFrame to dwuwymiarowa struktura danych podobna do tabeli w bazie danych lub arkusza kalkulacyjnego Excela. DataFrame składa się z wierszy i kolumn – każda kolumna w DataFrame to Series. Jak pewnie się domyślasz, mimo że dana kolumna zawiera tylko jeden typ danych, to DataFrame może zawierać wiele kolumn, z których każda ma dane innego typu. Przykładem może być utworzenie DataFrame z danych na temat transakcji dokonywanych przez klientów, których identyfikujemy po ID.

import pandas as pd

ct_data = {

    'client_id': ['C34P', 'C35S', 'C35P', 'C97S', 'C58S'],

    'card_transactions': [11, 244, 31, 458, 63]

}

client_transaction_df = pd.DataFrame(ct_data)

print(client_transaction_df)

Wczytywanie danych z różnych źródeł

Jedną z najważniejszych zalet biblioteki Pandas jest łatwość, z jaką można wczytać dane z różnych źródeł i formatów plików. Do najpopularniejszych należą: 

• CSV 
• Excel (.xlsx) 
• SQL 
• Pliki płaskie (flat files, np. plik tekstowy) 

Dane z pliku CSV można wczytać do DataFrame za pomocą funkcji pd.read_csv(). 

import pandas as pd

df = pd.read_csv('path_to_your_file.csv')

print(df)

Podobnie, możemy wczytać plik Excela za pomocą funkcji pd.read_excel(). 

import pandas as pd

df = pd.read_excel('path_to_your_file.xlsx')

print(df)

Aby wczytać wynik zapytania SQL, musimy najpierw utworzyć połączenie do bazy danych. Na przykładzie bazy danych SQLite możemy zrobić to w następujący sposób:

import pandas as pd

import sqlite3

# Ustanawianie połączenia do bazy danych

conn = sqlite3.connect("database_name.db")

# Wykonanie zapytania

df = pd.read_sql_query("SELECT * FROM my_table", conn)

print(df)

Zakładając, że korzystasz z innej bazy danych, musisz zainstalować odpowiedni sterownik dla Pythona i zastąpić sqlite3.connect odpowiednim połączeniem. Jeżeli chcesz dowiedzieć się więcej na temat sqlite, zachęcam cię do odwiedzenia dokumentacji sqlite3.

W następnym rozdziale omówimy podstawowe operacje na danych z wykorzystaniem Series i DataFrame. 

Podstawowe operacje na danych

Kiedy już wiesz, jak wczytać dane za pomocą biblioteki Pandas, skupimy się teraz na wybieraniu, filtrowaniu i sortowaniu danych oraz zastosowaniu funkcji apply i map.

Wybieranie, filtrowanie i sortowanie danych

Jedną z podstawowych i najczęściej używanych operacji jest wybieranie określonych danych z DataFrame. Pandas umożliwia wybieranie danych na wiele sposobów: 

• Wybieranie kolumn: df[’nazwa_kolumny’] 
• Wybieranie wierszy za pomocą numerów indeksów: df.iloc[indeks] 
• Wybieranie wierszy za pomocą etykiet indeksów: df.loc[etykieta]

Przykładowy fragment kodu zamieszczam poniżej: 

import pandas as pd

ct_data = {

    'client_id': ['C34P', 'C35S', 'C35P', 'C97S', 'C58S'],

    'count': [11, 244, 31, 458, 63]

}

df = pd.DataFrame(ct_data)

print(df)

# Wybieranie kolumny 'client_id'

print(df['client_id'])

 

# Wybieranie pierwszego wiersza

print(df.iloc[0])

# Wybieranie wiersza o etykiecie indeksu zero

print(df.loc[0])

Filtrowanie to proces wybierania podzbioru danych na podstawie zadanych kryteriów. Przykładowo, możemy chcieć wybrać tylko te transakcje, które są dostępne w ilości większej niż 60:

filtered_df = df[df['count'] > 60]

print(filtered_df)

Sortowanie danych jest prostym procesem, który możemy przeprowadzić za pomocą metody sort_values():

sorted_df = df.sort_values('count')

print(sorted_df)

Operacje na kolumnach: dodawanie, usuwanie, zmiana nazw

Aby dodać nową kolumnę do DataFrame, możemy po prostu przypisać dane do nowej kolumny, jak w poniższym przykładzie: 

df['amount'] = [1200, 4500, 3000, 28000, 700] # -- dodajemy kolumnę z sumą kwot, na które wykonano transakcje

print(df)

Aby usunąć kolumnę, skorzystamy z metody drop():

df = df.drop('amount', axis=1)

print(df)

Zmiana nazwy kolumny jest możliwa za pomocą metody rename():

df = df.rename(columns={'client_id': 'client_code', 'count': 'quantity'})

print(df)

Użycie funkcji apply i map

Funkcje apply i map pozwalają na zastosowanie wybranej funkcji do każdego elementu zapisanego w Series lub DataFrame. Przykładowo, użycie funkcji z biblioteki NumPy dla kolumny ‘quantity’.

import numpy as np

df['log_quantity'] = df['quantity'].apply(np.log)

print(df)

Metoda map jest podobna do apply, ale działa tylko na Series. Jest często używana do zamiany wartości na podstawie słownika. Przykładowo, dla listy klientów chcemy dodać dodatkową cyfrę w identyfikatorze.

code_map = {

    'C34P': '0C34P',

    'C35S': '1C35S',

    'C35P': '1C35P',

    'C97S': '0C97S',

    'C58S': '0C58S'

}

df['client_code'] = df['client_code'].map(code_map)

print(df)

Czyszczenie i naprawa brakujących danych

Praca z danymi, które pochodzą ze źródeł rzeczywistych, praktycznie zawsze wiąże się z koniecznością ich czyszczenia lub poprawiania. Często dane zawierają braki, duplikaty lub typy danych, które nie są odpowiednie do planowanej analizy. W tym rozdziale omówię proste sytuacje i pokażę ci, jak radzić sobie z takimi problemami za pomocą narzędzi z biblioteki Pandas.

Obsługa brakujących danych (NaN)

Brakujące dane są oznaczane jako NaN (Not a Number). Pandas oferuje kilka metod do obsługi brakujących danych i są to np.: 

• Wypełnianie brakujących danych określoną wartością 
• Usuwanie wierszy z brakującymi danymi 

Metoda fillna() pozwala na wypełnienie brakujących danych określoną wartością lub za pomocą określonej metody (np. ’forward fill’  – ffill, ’backward fill’  – bfill): 

import numpy as np

data = {

    'A': [1, 2, np.nan],

    'B': [5, np.nan, np.nan],

    'C': [1, 2, 3]

}

df = pd.DataFrame(data)

df_filled_zeros = df.fillna(value=0)  # --Wypełniamy brakujące dane wartością 0

print(df_filled_zeros)

Możliwe jest też usunięcie wierszy, które zawierają brakujące dane. W przypadku dużego zbioru i niewielkiej liczby “zepsutych” wierszy nie powinno mieć to dużego wpływu na jakość danych, ale przy niewielkim zbiorze usunięcie kilku wierszy może znacząco wpłynąć na późniejszą analizę. Jeżeli jednak zdecydujesz się na usunięcie wybranych wierszy, to możesz użyć metody dropna():.

df_dropped = df.dropna()  # Usuwamy wiersze z brakującymi danymi

print(df_dropped)

Czasami dochodzi do sytuacji, że w naszym zbiorze znajduje się wiele duplikatów, które z punktu widzenia analizy są zbędne. Usunięcie duplikatów jest przydatne szczególnie w sytuacji, gdy stanowią one większość naszego zbioru. Pozbycie się ich pozwoli na odciążenie biblioteki i wydajniejsze operacje np. na kolumnach w DataFrame. Pandas dostarcza metodę drop_duplicates(), która pozwala na łatwe usunięcie duplikatów:

data = {

    'client_id': ['C34P', 'C35S', 'C35P', 'C35P','C97S', 'C58S', 'C58S'],

    'count': [11, 244, 31, 31, 458, 63, 63]

}

df = pd.DataFrame(data)

df = df.drop_duplicates()  # Usuwamy duplikaty

print(df)

Więcej o pracy z brakującymi danymi dowiesz się z obszernej dokumentacji na Pydata.org.  

Jeżeli pracujesz na danych dostarczanych przez inne osoby lub firmy, możesz spotkać się z danymi numerycznymi (liczby całkowite, cyfry, liczby zmiennoprzecinkowe), które przedstawione są jako ciągi znaków (string). Czyli np. liczba całkowita 200 w DataFrame zapisana jest jako string o wartości ‘200’. Interpreter potraktuje to jako tekst, a nie liczbę. Jeżeli chcesz wykonywać na takich danych operacje statystyczne lub matematyczne, konieczne jest zmienienie typu danych kolumny (w tym przypadku z ‘str’ na ‘int’). Możemy to zrobić za pomocą metody astype():

import pandas as pd

data = {

    'client_id': ['C34P', 'C35S', 'C35P', 'C97S', 'C58S'],

    'count': ['11', '244', '31', '458', '63']

}

df = pd.DataFrame(data)

df['count'] = df['count'].astype(int)  # Zmieniamy typ danych kolumny 'count' na int

print(df)

Podsumowując, czyszczenie danych to zazwyczaj niezbędny krok w procesie przetwarzania i analizy danych. Pandas oferuje wiele narzędzi, które ułatwiają ten proces. Jeżeli chcesz dowiedzieć się więcej o pracy z plikami tekstowymi, oto link do dokumentacji:

1. 1. Analiza danych a odpowiednia biblioteka w języku Python
2. 2. Instalacja
3. 3. Podstawy tworzenia i omówienie struktury wykresów
4. 4. Popularne rodzaje wykresów w Matplotlib
5. 5. Dostosowanie wykresu
6. 6. Wykresy wieloosiowe
7. 7. Podsumowanie i cheat sheet

Analiza danych a odpowiednia biblioteka w języku Python

Jeżeli kiedykolwiek zdarzyło ci się wykonywać analizę danych, to wiesz, jak ważne jest przedstawienie wyników pracy w sposób szybki i czytelny. Możesz łatwo zobrazować pewne wzorce, anomalie i trendy, które są wynikiem twojej pracy. Jest to szczególnie przydatne w przygotowaniu prezentacji lub raportów biznesowych dla osób nietechnicznych. Wizualizacja wyników pozwala na łatwiejsze przedstawienie obserwacji, a korzystając z narzędzi dostarczonych przez bibliotekę Matplotlib, masz pewność, że cały proces jest wydajny, prosty i elastyczny. Za pomocą kilku linijek kodu otrzymujesz dostęp do podstawowych i zaawansowanych funkcji, które są bezpłatne, bo Matplotlib jest biblioteką open-source.

Szczególnie wydajne jest połączenie możliwości tej biblioteki z innymi bibliotekami naukowymi, takimi jak NumPy, Pandas czy SciPy.

Zakładam, że znasz podstawy języka Python. Jeżeli nie, to nie przejmuj się, ponieważ kod, który tutaj przedstawiam, możesz łatwo zrozumieć i uruchomić po przejściu jednego z kursów programowania w języku Python dostępnych w sieci. Podstawowa składnia wystarczy ci do skorzystania z tego artykułu. Przejdźmy więc do instalacji i konfiguracji środowiska.

Instalacja biblioteki Matplotlib

Na komputerze powinien znajdować się zainstalowany Python w wersji 3.x.

Bibliotekę Matplotlib możesz zainstalować za pomocą menedżera pakietów ‘pip’. Otwórz terminal lub wiersz poleceń (lub PowerShell) dla systemu Windows i wpisz komendę:

pip install matplotlib

Jeżeli korzystasz z Pythona 2.x to skorzystaj z komendy ‘pip2’.

Niektórzy użytkownicy używają narzędzia Anaconda lub Miniconda. W tym przypadku skorzystaj z menadżera pakietów ‘conda’:

conda install matplotlib

W przypadku poprawnego zakończenia procesu instalacji możemy zaimportować bibliotekę do naszego projektu. Zazwyczaj importuje się główny moduł tej biblioteki, czyli ‘pyplot’. Zawiera on niezbędne funkcje do generowania wykresów.

import matplotlib.pyplot as plt

Sama biblioteka korzysta z domyślnych stylów podczas „upiększania” i modyfikacji wykresów. Są to np. modyfikacje kolorystyczne, czcionki, dodawanie dodatkowych informacji, legend itd. Jeżeli chcesz zapoznać się z różnymi stylami, które oferuje Matplotlib, to zajrzyj do dokumentacji lub skorzystaj z komendy ‘print’:

print(plt.style.available)

W celu użycia konkretnego stylu w twoim projekcie skorzystaj z funkcji:

plt.style.use(‘nazwa_stylu’) # np. ‘seaborn’

Konfigurację możesz dostosować według własnych preferencji, modyfikując konkretne wartości parametrów z użyciem funkcji:

plt.rcParams.update({'font.size': 10, 'figure.figsize': (10, 8)})

W tym artykule będę korzystał z domyślnego stylu, ale zachęcam cię do wybrania i dostosowania tego, który najbardziej ci odpowiada. Przejdźmy teraz do podstaw tworzenia wykresów w Matplotlib.

Podstawy tworzenia i omówienie struktury wykresów

Koncepcję i strukturę wykresu w bibliotece Matplotlib najprościej można wyjaśnić za pomocą wykresu liniowego. Wykresy tworzone są na podstawie tzw. Figur ‘figure’. Figura może zostać opisana jako kontener na jedną lub więcej osi ‘axes’. Osiami określamy powierzchnię wykresu, na której rysowane są dane. Jeżeli mowa o wykresie 2D, to zawierał on będzie osie X i Y, a np. wykres 3D X, Y i Z. Do danego wykresu przypisać można również elementy opisujące. Mogą to być etykiety osi, legendy, tytuły i wartości, np. nad słupkami.

W celu utworzenia prostego wykresu liniowego skorzystamy ze wspomnianej wcześniej biblioteki NumPy (odsyłam do mojego poprzedniego artykułu). Stworzymy listę zawierającą wartości liczbowe dla osi X oraz skorzystamy z wartości funkcji sinus dla osi Y.

import numpy as np 

import matplotlib.pyplot as plt 

# Przygotowanie danych 

x = np.linspace(0, 10, 100) 

y = np.sin(x) 

W celu utworzenia wykresu liniowego o krzywej sinusoidalnej użyjemy funkcji ‘plot()’, a następnie wyświetlimy go za pomocą funkcji ‘show()’. Jeżeli uruchomisz poniższy kod, to powinien wyświetlić ci się na ekranie wykres liniowy, który przedstawia funkcję sinus.

plt.plot(x, y)  # Rysowanie wykresu liniowego 

plt.show()  # Wyświetlenie wykresu 

Jak się pewnie domyślasz, wykres ten nie jest zbyt czytelny, ponieważ poza wartościami same osie nie zostały opisane, wykres nie posiada tytułu, a więc nie jesteśmy w stanie określić, co on tak naprawdę przedstawia. Możemy się domyślać, że chodzi o funkcję sinus, ale lepiej poprawić ten wykres, żeby był bardziej czytelny, szczególnie dla osoby bez znajomości wybranych zagadnień matematycznych. Dodamy zatem tytuł wykresu ‘title()’, etykiety osi ‘xlabel()’, ‘ylabel()’ oraz legendę.

plt.plot(x, y, label='sin(x)')  # Dodanie etykiety dla serii danych (do legendy) 

plt.xlabel('X')  # Etykieta osi X 

plt.ylabel('Y')  # Etykieta osi Y 

plt.title('Wykres funkcji sinus')  # Tytuł wykresu 

plt.legend()  # Dodanie legendy 

plt.show()  # Wyświetlenie wykresu 

Wiesz już, jak stworzyć prosty wykres liniowy, ale co w przypadku gdy istnieje potrzeba prezentacji danych za pomocą innych wykresów? Zajmiemy się nimi w dalszej części, gdzie omówię wybrane ich rodzaje.

Popularne rodzaje wykresów w Matplotlib

Omawiana biblioteka pozwala na dostosowanie naszych wizualizacji do konkretnego przypadku, a przykłady, które podaję, to tylko niektóre z oferowanych możliwości. Jeżeli spędzisz z tą biblioteką więcej czasu, to z pewnością poznasz wiele więcej funkcji i możliwości, a to przełoży się na jeszcze lepsze przedstawianie danych i intuicyjne przekazywanie informacji.

Poza wykresem liniowym popularne są także: 

1. Wykresy punktowe (Scatter plot) – zbiór punktów, które nie są ze sobą połączone. Używany w wizualizacji korelacji pomiędzy zmiennymi, rozkładu wartości albo określania grup. Przykładem zastosowania może być analiza badania demograficznego pod kątem zależności między wiekiem a zarobkami lub doświadczeniem grupy badanej. Poniżej znajduje się fragment kodu, który pozwala utworzyć wykres punktowy.

import numpy as np 

import matplotlib.pyplot as plt 

# Przykładowe dane 

wiek = np.random.randint(18, 65, 100) 

zarobki = np.random.normal(50000, 10000, 100) + (wiek - 18) * 1000 

plt.scatter(wiek, zarobki) 

plt.xlabel('Wiek') 

plt.title('Związek między wiekiem a rocznymi zarobkami') 

plt.show() 

2. Histogram – jest rodzajem wykresu słupkowego, który ilustruje rozkład wartości danych. Wykorzystywany do wizualizacji częstotliwości występowania wartości w wybranym zbiorze danych. Prostym przykładem może być wizualizacja rozkładu ocen w grupie uczniów. Poniżej zamieszczam kod, za pomocą którego wygenerujesz histogram. 

oceny = np.random.normal(3.5, 0.5, 200) 

plt.hist(oceny, bins=20, alpha=0.7, label='Oceny uczniów') 

plt.xlabel('Ocena') 

plt.ylabel('Częstotliwość') 

plt.title('Rozkład ocen w grupie uczniów') 

plt.legend() 

plt.show() 

3. Wykres słupkowy – jeden z najpopularniejszych wykresów, który przedstawia dane za pomocą poziomych lub pionowych słupków. Zazwyczaj ułatwia porównanie danych, które pogrupowano w konkretne kategorie. Przykładem może być porównanie średnich wyników drużyn w lidze sportowej. Poniżej zamieszczam kod i zrzut ekranu przykładowego wykresu. 

plt.bar(druzyny, srednie_wyniki, alpha=0.7) 

plt.xlabel('Drużyny') 

plt.ylabel('Średni wynik') 

plt.title('Porównanie średnich wyników drużyn w lidze sportowej') 

plt.show() 

4. Wykres kołowy – dane znajdują się w sektorach w obrębie koła. Doskonale obrazuje proporcje poszczególnych elementów lub grup względem całości. Przykładem może być wykres na podstawie analizy udziału dostawców energii na rynku w Unii Europejskiej. Kod i wykres zostały zamieszczone poniżej.  

firmy = ['Firma A', 'Firma B', 'Firma C', 'Firma D'] 

udzialy_rynku = [35, 25, 20, 20] 

plt.pie(udzialy_rynku, labels=firmy, autopct='%.1f%%', startangle=90) 

plt.axis('equal') 

plt.title('Struktura rynkowa w sektorze energetycznym') 

plt.show() 

5. Mapa ciepła (heatmap) – nie jest typowym wykresem znanym np. ze szkoły, ponieważ występuje w postaci macierzy, na której kolory odpowiadają wartościom konkretnych komórek. Dobrze obrazuje korelacje i gradienty wartości oraz wykrywa wzorce w przypadku danych dwuwymiarowych. Przykładem użycia może być poziom ekspresji genów w zależności od stworzonych warunków eksperymentalnych. 

data = np.random.rand(10, 10) 

plt.imshow(data, cmap='hot', interpolation='nearest') 

plt.colorbar() 

plt.title('Mapa ciepła (heatmap)') 

plt.show() 

# Mapa ciepła dla ekspresji genów 

geny = 50 

warunki = 10 

ekspresja_genow = np.random.rand(geny, warunki) 

plt.imshow(ekspresja_genow, cmap='coolwarm', aspect='auto') 

plt.colorbar() 

plt.xlabel('Warunki eksperymentalne') 

plt.ylabel('Geny') 

plt.title('Poziomy ekspresji genów w warunkach eksperymentalnych') 

plt.show() 

6. Wykres konturowy – używany jest do obrazowania danych trójwymiarowych w postaci linii poziomicy na powierzchni dwuwymiarowej. Wizualizuje wartości, które są równe dla konkretnej funkcji na danej płaszczyźnie. Przykładem może być np. wizualizacja danych pogodowych lub wartości ciśnienia atmosferycznego na mapie meteorologicznej.  

x = np.linspace(-10, 40, 100)  # długość geograficzna dla Europy (w przybliżeniu) 

y = np.linspace(35, 70, 100)   # szerokość geograficzna dla Europy (w przybliżeniu) 

X, Y = np.meshgrid(x, y) 

cisnienie = 1000 + 10 * np.sin(np.sqrt((X - 10)**2 + (Y - 50)**2)) 

plt.contour(X, Y, cisnienie, levels=20, cmap='coolwarm') 

plt.xlabel('Długość geograficzna') 

plt.ylabel('Szerokość geograficzna') 

plt.title('Ciśnienie atmosferyczne na mapie meteorologicznej') 

plt.colorbar(label='hPa') 

plt.show() 

7. Wykres 3D – powierzchniowy dla funkcji dwóch zmiennych, w tym przypadku funkcji sinusoidalnej na siatce punktów. 

import numpy as np 

import matplotlib.pyplot as plt 

from mpl_toolkits.mplot3d import Axes3D 

# Definiowanie danych 

x = np.linspace(-5, 5, 100) 

y = np.linspace(-5, 5, 100) 

x, y = np.meshgrid(x, y) 

z = np.sin(np.sqrt(x**2 + y**2)) 

# Inicjalizacja wykresu 3D 

fig = plt.figure() 

ax = fig.add_subplot(111, projection='3d') 

# Tworzenie wykresu powierzchniowego 

surf = ax.plot_surface(x, y, z, cmap='plasma', edgecolors='k', linewidth=0.5) 

# Dodanie paska kolorów 

cbar = fig.colorbar(surf, pad=0.15, shrink=0.5, aspect=5) 

cbar.ax.yaxis.set_ticks_position('right') 

# Etykiety osi 

ax.set_xlabel('Oś X', labelpad=10) # labelpad zapobiega nakładaniu się osi 

ax.set_ylabel('Oś Y', labelpad=10) 

ax.set_zlabel('Oś Z', labelpad=10) 

# Tytuł wykresu 

ax.set_title('Wykres powierzchniowy') 

plt.show() 

Pamiętaj, że powyższe kody i wygenerowane wykresy to tylko przykłady i nie muszą odzwierciedlać realnych sytuacji czy danych. Zachęcam cię do sprawdzenia wszystkich rodzajów wykresów, które szczegółowo opisane są w dokumentacji: Plot types — Matplotlib 3.7.1 documentation.

Znasz już podstawowe rodzaje wykresów i wiesz, jak je tworzyć, dlatego w dalszej części tego artykułu na przykładzie wykresu słupkowego pokażę ci, jak możesz dostosować wizualizacje, wykorzystując kilka dodatkowych elementów, jak siatka, linie pomocnicze i wartości nad słupkami, czyli etykiety (labels).

Dostosowanie wykresu

Poniżej znajduje się prosty wykres ukazujący zestawienie dochodu firmy X na przestrzeni ostatnich 7 lat. Kod i wykres zamieszczam poniżej. 

import matplotlib.pyplot as plt 

# Przykładowe dane 

lata = ['2016', '2017', '2018', '2019', '2020', '2021', '2022'] 

dochody = [32, 45, 58, 64, 49, 59, 72] 

plt.bar(lata, dochody, alpha=0.7) 

plt.xlabel('Rok budżetowy') 

plt.ylabel('Dochód (tys. PLN)') 

plt.title('Zestawienie dochodów w tys. PLN na przestrzeni 7 lat') 

plt.plot(lata, dochody) 

plt.show() 

Dodajmy do wykresu kilka dodatkowych elementów, żeby sprawić, by stał się czytelniejszy i odrobinę bardziej atrakcyjny wizualnie.

import numpy as np 

import matplotlib.pyplot as plt 

# Przykładowe dane 

lata = ['2016', '2017', '2018', '2019', '2020', '2021', '2022'] 

dochody = [32, 45, 58, 64, 49, 59, 72] 

x_pos = np.arange(len(lata)) 

bars = plt.bar(x_pos, dochody, alpha=0.7) 

plt.xticks(x_pos, lata) 

plt.xlabel('Rok budżetowy') 

plt.ylabel('Dochód (tys. PLN)') 

plt.title('Zestawienie dochodów w tys. PLN na przestrzeni 7 lat') 

plt.plot(lata, dochody, 

         color='red', 

         linestyle='--', 

         linewidth=3, 

         marker='o', 

         markersize=10, 

         label='Linia') 

plt.grid(True, linestyle='--', linewidth=0.5, alpha=0.7, color='black') 

plt.gca().set_facecolor('whitesmoke') 

for bar in bars: 

    height = bar.get_height() 

    plt.text(bar.get_x() + bar.get_width() / 2, height + 1, str(height), ha='center', va='bottom') 

plt.show() 

W powyższym przykładzie na uwagę zasługuje funkcja ‘text()’, która znajduje się w pętli ‘for’. Wspomniana funkcja dodaje wartości nad każdym ze słupków wskazujących na dochód w poszczególnych latach. Jako argumenty przekazujemy położenie na osi X (bar.get_x() + bar.get_width() / 2) oraz położenie na osi Y (height + 1), a także tekst, który ma wyświetlić się nad słupkami (str(height)) i parametry wyrównania tekstu wobec współrzędnych, odpowiednio ‘ha’ – horizontal alignment i ‘va’ – vertical alignment. W celu zapoznania się z innymi metodami i rodzajami nakładania etykiet (wartości) w wykresach słupkowych, ale też innych rodzajach wykresów, odsyłam do dokumentacji Matplotlib: Bar Label Demo — Matplotlib 3.7.1 documentation.

Wykresy wieloosiowe

Czasami zdarzy się, że na jednej figurze (nie mylić z wykresem) chcesz umieścić dwa lub więcej wykresów. Na przykład, tworzysz prezentację na potrzeby szkolenia matematycznego dla licealistów i chcesz przedstawić wykres funkcji sinus i cosinus. W celu dodania kolejnego wykresu do tej samej figury możemy skorzystać z funkcji ‘add_subplot()’ lub funkcji ‘subplots()’. Oczywiście każdy wykres lub oś będzie trzeba skonfigurować osobno, ale jak już wiesz, nie są to skomplikowane operacje. Kod i wykresy na jednej figurze zamieszczam poniżej:

import numpy as np 

import matplotlib.pyplot as plt 

x = np.linspace(0, 10, 100) 

y1 = np.sin(x) 

y2 = np.cos(x) 

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 6)) 

# Ustawienie odstępu między wykresami 

plt.subplots_adjust(hspace=0.5) 

ax1.plot(x, y1, color='blue', label='sin(x)') 

ax1.set_xlabel('Oś X') 

ax1.set_ylabel('sin(x)') 

ax1.legend() 

ax2.plot(x, y2, color='red', label='cos(x)') 

ax2.set_xlabel('Oś X') 

ax2.set_ylabel('cos(x)') 

ax2.legend() 

plt.show() 

Pierwszy wykres (na górze) przedstawia funkcję sinusoidalną sin(x), gdzie wartość na osi X jest przedstawiona przez x, a wartość na osi Y przedstawia sin(x). Wykres ma niebieski kolor linii i etykietę ‘sin(x)’.

Drugi wykres (na dole) przedstawia funkcję cosinusoidalną cos(x), gdzie wartość na osi X jest przedstawiona przez x, a wartość na osi Y przedstawia cos(x). Wykres ma czerwony kolor linii i etykietę ‘cos(x)’.

Oba wykresy są umieszczone w jednej kolumnie i dwóch wierszach, ze wspólną osią X, która przedstawia zakres wartości x od 0 do 10. W kolejnym przykładzie pokażę ci nałożenie wykresów na siebie.

Wieloosiowe wykresy mogą być przydatne w różnych zastosowaniach, takich jak:

• Porównywanie różnych wielkości na jednym wykresie.
• Przedstawianie wielkości w różnych jednostkach lub zakresach wartości.
• Prezentowanie danych związanych z czasem, gdzie wartości dla różnych wielkości mają wspólną oś czasu.

Poniżej przedstawiam przykład z nałożonymi krzywymi (sinus i cosinus) na jednym wykresie.

import numpy as np 

import matplotlib.pyplot as plt 

x = np.linspace(0, 10, 100) 

y1 = np.sin(x) 

y2 = np.cos(x) 

fig, ax1 = plt.subplots(figsize=(8, 4)) # figsize pozwala na ustalenie rozmiaru figury 

# Rysowanie sinusa na pierwszej osi 

ax1.plot(x, y1, color='blue', label='sin(x)') 

ax1.set_xlabel('Oś X') 

ax1.set_ylabel('sin(x)', color='blue') 

ax1.tick_params(axis='y', labelcolor='blue') 

# Tworzenie drugiej osi dla cosinusa 

ax2 = ax1.twinx() 

ax2.plot(x, y2, color='red', label='cos(x)') 

ax2.set_ylabel('cos(x)', color='red') 

ax2.tick_params(axis='y', labelcolor='red') 

# Dodawanie legendy 

fig.legend(loc='upper right') 

plt.grid(True, linestyle='--', linewidth=0.5, alpha=0.7, color='black') 

plt.title('Wykres wieloosiowy z sin(x) i cos(x)') 

plt.show() 

W powyższym przykładzie, ax1 jest osią Y dla sin(x), a ax2 jest osią Y dla cos(x). Używając funkcji twinx(), utworzyliśmy drugą oś Y, która współdzieli wspólną oś X z pierwszą osią Y. Następnie narysowaliśmy funkcje sinusoidalną i cosinusoidalną na odpowiednich osiach, używając różnych kolorów dla linii i etykiet. W ten sposób obie funkcje są przedstawione na jednym wykresie z dwiema osiami Y. Rozmiar figury został zmieniony na 8 cali szerokości i 4 cale wysokości za pomocą parametru ‘figsize’. Zachęcam do eksperymentowania z parametrami w celu uzyskania optymalnych rozwiązań. Ponownie odsyłam do dokumentacji w celu zapoznania się z pełnym zakresem parametrów.

Podsumowanie i cheat sheet

Myślę, że w tym artykule udało mi się pokazać ci podstawy tworzenia wykresów i pracy z biblioteką Matplotlib. Zebrałem też najważniejsze funkcje i fragmenty kodu, które możesz wykorzystać podczas pracy z wizualizacjami, korzystając z Matplotlib.

Importowanie biblioteki:

import matplotlib.pyplot as plt 

Tworzenie wykresów:

# Wykres liniowy 

plt.plot(x, y) 

# Wykres punktowy (scatter plot) 

plt.scatter(x, y) 

# Histogram 

plt.hist(x, bins) 

# Wykres słupkowy (bar plot) 

plt.bar(x, y) 

# Wykres kołowy (pie chart) 

plt.pie(values, labels=labels) 

# Heatmap 

plt.imshow(matrix, cmap='hot') 

# Wykres konturowy (contour plot) 

plt.contour(X, Y, Z) 

Wyświetlanie wykresu:

plt.show() 

Formatowanie wykresów:

# Tytuł wykresu 

plt.title("Tytuł") 

# Etykiety osi 

plt.xlabel("Oś X") 

plt.ylabel("Oś Y") 

# Legenda 

plt.legend() 

# Siatka (grid) 

plt.grid() 

# Ograniczenie zakresu osi 

plt.xlim(min_x, max_x) 

plt.ylim(min_y, max_y) 

# Skala logarytmiczna 

plt.xscale('log') 

plt.yscale('log') 

Personalizacja wykresów: 

# Kolor linii 

plt.plot(x, y, color='red') 

# Styl linii (liniowy, przerywany, kropkowany) 

plt.plot(x, y, linestyle='-') 

plt.plot(x, y, linestyle='--') 

plt.plot(x, y, linestyle=':') 

# Znaczniki punktów 

plt.plot(x, y, marker='o') 

plt.plot(x, y, marker='x') 

plt.plot(x, y, marker='+') 

# Grubość linii 

plt.plot(x, y, linewidth=2) 

Tworzenie wykresów wieloosiowych: 

# Tworzenie wykresów z wieloma osiami Y 

fig, ax1 = plt.subplots() 

ax2 = ax1.twinx() 

ax1.plot(x1, y1, 'g-') 

ax2.plot(x2, y2, 'b-') 

ax1.set_xlabel('Oś X') 

ax1.set_ylabel('y1', color='g') 

ax2.set_ylabel('y2', color='b') 

Zapisywanie wykresu jako obraz: 

plt.savefig("nazwa_pliku.png", dpi=300) 

Link do dokumentacji Matplotlib: 
Matplotlib documentation — Matplotlib 3.7.1 documentation

1. 1. Czym właściwie jest biblioteka Python?
2. 2. Do czego służy pakiet NumPy?
3. 3. Instalacja NumPy
4. 4. Czym są tablice w NumPy?
5. 5. Różnica między ndarray a array
6. 6. Funkcje wbudowane
7. 7. Porównanie czasu wykonania funkcji w NumPy i bez użycia tej biblioteki
8. 8. Zalety i wady korzystania z NumPy
9. 9. Podsumowanie – FAQ

Czym właściwie jest biblioteka Python?

Jeżeli od pewnego czasu programujesz w języku Python, na pewno korzystasz z różnych bibliotek, które wspierają implementację rozwiązań i zwiększają wydajność zarówno twoją, jak i funkcjonalności, nad którymi pracujesz. Najpopularniejsze biblioteki w języku Python to m.in. Pandas, NumPy, TensorFlow czy SciPy.

Biblioteka w języku Python to w dużym uproszczeniu zbiór funkcji i metod, które stworzono w celu ułatwienia implementacji rozwiązań. Funkcje te można w łatwy sposób wykorzystać w programie, nie tracąc czasu na tworzenie wszystkiego od zera. To pewnego rodzaju moduły, które zostały stworzone w celu ułatwienia pracy z problemami konkretnych obszarów nauki czy biznesu.

Wiele bibliotek Python używanych jest np. na potrzeby medycyny (MedPy), przemysłu ciężkiego, lotnictwa, bankowości czy telekomunikacji i wojskowości. Biblioteki mogą także wspierać wąskie specjalizacje obszaru IT, takie jak przetwarzanie i wizualizacja zbiorów danych (Pandas, Matplotlib), sieci neuronowe (TensorFlow, PyTorch), a także obliczenia naukowe (SciPy).

Każda biblioteka posiada dokumentację, która objaśnia możliwości wykorzystania zawartych w niej funkcji i metod. Dokumentacja zazwyczaj zawiera też fragmenty kodu, które po niewielkim dostosowaniu można z powodzeniem użyć we własnym projekcie.

Do czego służy pakiet NumPy?

Jak zapewne wiesz, analiza danych (ang. Data Science) staje się z roku na rok coraz popularniejsza, a w momencie pisania tego artykułu jej wykorzystanie stało się w zasadzie powszechne w wielu obszarach biznesu. Obok różnych procesów dotyczących przygotowania danych czy wizualizacji efektów stoją metody obliczeniowe, które wspomagają uzyskanie realnej wartości z zebranych danych. W tym artykule skupiam się na danych numerycznych.

Języki programowania, do których należy Python, wspomagają naukowców, analityków i programistów w implementacji rozwiązań i osiąganiu rezultatów, które z powodzeniem mogą zostać użyte w procesach decyzyjnych wyższego szczebla i mieć realny wpływ na otaczający nas świat. W przypadku wspomnianych metod obliczeniowych jedną z najpopularniejszych bibliotek jest właśnie NumPy (Numeric Python). Jak nazwa wskazuje, skupia się ona głównie na wsparciu pracy z danymi numerycznymi i umożliwia efektywne i wydajne dokonywanie operacji na macierzach, tablicach czy wektorach, które zawierają elementy tego samego typu. Po wprowadzeniu teoretycznym skupimy się bardziej na części praktycznej i bazując na prostych przykładach, zapoznasz się z możliwościami biblioteki NumPy. Zanim to jednak zrobimy, upewnij się, że biblioteka NumPy jest u ciebie zainstalowana.

Instalacja NumPy

Instalacja NumPy została szczegółowo wyjaśniona w części FAQ. Jeżeli biblioteka NumPy jest już zainstalowana, możesz przejść do kolejnej części.

Nieważne, czy korzystasz z linii poleceń, IDE (np. PyCharm) czy notebooka (np. Jupyter). Jedyne, co musisz zrobić, żeby móc korzystać z NumPy, to napisać linijkę kodu odpowiedzialnego za import biblioteki.

import numpy as np

Od teraz możesz korzystać ze wszystkich możliwości, jakich dostarcza NumPy. Zachęcam cię do samodzielnego uruchomienia fragmentów kodu, które zawarte są w tym artykule, i modyfikacji według uznania, żeby lepiej zrozumieć zasady działania i możliwości omawianej biblioteki.

Skupmy się najpierw na rzeczach prostych, jakimi są np. podstawowe operacje arytmetyczno-logiczne. Do tego niezbędne jest zrozumienie kluczowej struktury, którą wprowadzono w NumPy, czyli tablicy.

Teraz pewnie zastanawiasz się, dlaczego w ogóle masz korzystać z dodatkowej biblioteki, jeżeli wszystkie funkcjonalności możesz napisać z użyciem podstawowych rozwiązań w języku Python, jakimi są pętle (ang. loop) czy listy (ang. list). W profesjonalnym podejściu i pracy na ogromnych zbiorach danych (nie tylko numerycznych) często ważnym aspektem jest czas. I w tym tkwi właśnie przewaga NumPy, czyli w szybkości działania, która dodatkowo idzie w parze z niskim progiem wejścia dla użytkownika. W dalszej części artykułu przedstawię kilka przykładów, które wprowadzą cię w podstawy NumPy. Wykorzystane funkcje poprawiają wydajność w obliczeniach. A można to osiągnąć między innymi poprzez operacje na wspomnianych wcześniej tablicach.

Czym są tablice w NumPy?

Tablica (ang. array) w NumPy to struktura o jednym wymiarze lub większej liczbie wymiarów pozwalająca na działania ze zbiorami danych numerycznych, zaczynając od kilkuelementowych po ogromne zbiory przechowywane np. w chmurze. Pamiętajmy, że nie tylko wymiary charakteryzują tablicę – istnieje też kilka innych, równie ważnych cech.

• Tablice są stałej wielkości – nie możemy zmienić rozmiaru po jej utworzeniu.
• Przechowują elementy tego samego typu, np. liczby całkowite (ang. Integer) lub zmiennoprzecinkowe (ang. float-point).
• Wykorzystywane „pod spodem” algorytmy pozwalają na bardzo szybkie operacje i efektywne wykorzystanie pamięci.

Niektórzy porównują tablice do list w Pythonie, ale listy różnią się od tablic, np. możliwością przechowywania elementów różnego typu (listy mogą być heterogeniczne), a także są jednowymiarowe (chociaż możliwe jest przechowywanie jednowymiarowej listy w drugiej liście). To tyle z teoretycznego wprowadzenia. Poniżej zamieściłem kilka przykładów wraz z objaśnieniami.

W celu stworzenia tablicy możesz skorzystać z kilku opcji, między innymi:

1. Konwersja listy w tablicę.

import numpy as np
# jednowymiarowa tablica na podstawie listy
arr_1d = np.array([1, 2, 3])
# dwuwymiarowa tablica na podstawie listy
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])

2. Tablica o stałej wartości.

import numpy as np
# jednowymiarowa tablica wypełniona zerami o długości 3
arr_zeros = np.zeros(5)
# dwuwymiarowa tablica wypełniona jedynkami o wymiarach 3x3
arr_2d_ones = np.ones((3, 3))

3. Tablica z wartości losowych.

# jednowymiarowa tablica z losowymi wartościami z przedziału [0,1] o długości 3
arr = np.random.rand(3)
# dwuwymiarowa tablica z losowymi wartościami z rozkładu normalnego o wymiarach 3x3
arr_2d = np.random.randn(3, 3)

4. Tablica na podstawie pliku wejściowego.

import numpy as np
# inicjalizacja tablicy za pomocą pliku wejściowego
arr_file = np.loadtxt('file_name.txt')

Jak widzisz, lista opcji stworzenia tablicy nie ogranicza się do jednej czy dwóch, a powyższe przykłady jej nie wyczerpują. Ponieważ wiesz już czym są tablice i jak je stworzyć, możemy przejść do omówienia operacji z wykorzystaniem tablic numerycznych, które ułatwią obliczenia na dużych zbiorach danych.

NumPy – podstawowe operacje

import numpy as np
# tworzenie jednowymiarych tablic a i b
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# dodawanie tablicy b do tablicy a
c = a + b
# mnożenie tablicy a przez stałą 2
d = 2 * a

Wynikiem operacji logicznych takich jak AND (koniunkcja), OR (alternatywa) czy NOT (negacja) jest tablica zawierająca wartości logiczne True i False.

import numpy as np
# tworzenie jednowymiarych tablic a i b
a = np.array([1, 2, 3])
b = np.array([3, 2, 1])
# sprawdzamy, które elementy w tablicy a są mniejsze od odpowiadających im elementów w tablicy b
c = a < b
# sprawdzamy które elementy w tablicy a są równe 2 lub 3
d = (a == 2) | (a == 3)

Wynikiem operacji redukcyjnych takich jak suma, minimum, maksimum czy średnia jest skalar.

import numpy as np
# tworzenie jednowymiarowej tablicy a
a = np.array([1, 2, 3])
# suma elementów tablicy a
b = np.sum(a)
# średnia arytmetyczna dla elementów tablicy a
c = np.mean(a)
# największy element w tablicy a
d = np.max(a)

Dobrym przykładem jest także mnożenie macierzy i obliczenie wyznacznika, a także rozwiązanie układu równań liniowych.

import numpy as np
# tworzenie macierzy a i b
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
# operacja mnożenia macierzy a i b
c = np.dot(a, b)
# obliczenie wyznacznika macierzy a
d = np.linalg.det(a)
# wyznaczenie rozwiązania układu równań liniowych Ax = b
A = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])
x = np.linalg.solve(A, b)

Różnica między ndarray a array

Jeżeli zagłębiłeś się chociaż trochę bardziej w tematykę tablic w bibliotece NumPy, to możliwe, że spotkałeś się z numpy.ndarray() oraz numpy.array(). Prawdopodobnie zastanawiasz się, jaka jest różnica pomiędzy nimi – dlatego proponuję krótkie wyjaśnienie. Na wstępie zaznaczę, że podstawowa wiedza z programowania obiektowego lub pojęcia typu klasa i obiekt powinny być ci znane w celu poprawnego zrozumienia różnicy pomiędzy ndarray a array.

Zgodnie z dokumentacją i koncepcją języka Python numpy.ndarray() jest klasą, a numpy.array() jest metodą/funkcją, za pomocą której tworzymy obiekt ndarray, czyli właśnie tablicę. Wcześniej omówiliśmy, w jaki sposób możesz stworzyć tablicę w NumPy. Zgodnie z dokumentacją NumPy możliwe jest tworzenie tablicy bezpośrednio za pomocą numpy.ndarray(), ale zalecanym podejściem jest korzystanie z funkcji wbudowanych, np. numpy.array(), numpy.zeros() lub numpy.empty().

Funkcje wbudowane

Za definicją funkcji wbudowanej w NumPy nie stoi nic skomplikowanego. To po prostu funkcja, która została dostarczona przez bibliotekę. Oznacza to, że możesz wywołać taką funkcję bez potrzeby importowania dodatkowych modułów np. poza biblioteką NumPy. Funkcje wbudowane to najczęściej zbiór podstawowych funkcjonalności gotowych do wykorzystania po przekazaniu.

odpowiednich parametrów (jeżeli są wymagane). W przypadku NumPy jest to zbiór funkcji umożliwiających działania na tablicach, macierzach czy wektorach. Jeżeli chcesz w pełni wykorzystać potencjał biblioteki NumPy, korzystanie z funkcji wbudowanych jest niezbędne. W celu zapoznania się z pełną listą funkcji wbudowanych odsyłam cię do dokumentacji NumPy, a poniżej zamieszczam kilka wybranych przykładów.

1. Utworzenie tablicy z równo rozłożonymi elementami w wybranym zakresie.

import numpy as np
# tablica z 10 równo rozłożonymi wartościami w zakresie od 0 do 2
a = np.linspace(0, 2, 10)

2. Utworzenie macierzy i jej transpozycja.

import numpy as np
# tworzenie macierzy 3x3
x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# transpozycja macierzy a do macierzy b
b = np.transpose(a)

3. Sortowanie tablicy.

import numpy as np
# tworzenie tablicy z 10 elementami
a = np.array([3, 7, 3, 3, 2, 9, 7, 1, 5, 4])
# sortowanie tablicy
b = np.sort(a) 

4. Obliczenie transformaty Fouriera dla wybranej tablicy.

import numpy as np
# tworzenie tablicy z 6 elementami
a = np.array([1, 2, 3, 4, 5, 6])
# obliczanie transformaty Fouriera
b = np.fft.fft(a

5. Wygenerowanie pięciu losowych wartości z rozkładu normalnego.

import numpy as np
# ustalenie ziarna dla generatora liczb losowych
np.random.seed(12345)
# wygenerowanie pięciu losowych wartości z rozkładu normalnego
a = np.random.randn(5)

Powyżej zamieściłem kilka przykładów, zaczynając od tych o niskiej złożoności, ale niektóre z nich mogą wymagać znajomości bardziej zaawansowanych pojęć z obszarów matematyki, statystyki czy fizyki.

Porównanie czasu wykonania funkcji w NumPy i bez użycia tej biblioteki

Zanim omówię korzyści i potencjalne trudności wynikające z wykorzystania NumPy w twoim projekcie, chciałem pokazać ci różnice w czasie wykonania funkcji napisanej w języku Python bez dodatkowych bibliotek i tej z użyciem biblioteki NumPy. Użyjemy do tego dwóch przykładów. Pierwszy mierzy czas potrzebny na sumowanie losowych elementów z listy, a drugi pokazuje czas obliczania iloczynu skalarnego dwóch wektorów. Zwróć uwagę na to, że czas wykonania może się różnić w zależności od zasobów maszyny, na której uruchamiasz kod.

Przykład 1:

Pierwsza funkcja korzysta z numpy.sum(), a druga sumuje elementy z użyciem pętli for.

 import numpy as np
import time
# implementacja z użyciem NumPy
def numpy_sum(a):
return np.sum(a)
# implementacja bez dodatkowych bibliotek
def python_sum(a):
sum = 0
for i in a:
sum += i
return sum
# tworzenie listy z losowymi liczbami
a = np.random.randint(0, 100, 5000000)
# czas wykonania funkcji z NumPy
start_time = time.time()
numpy_sum(a)
print("Czas wykonania funkcji z NumPy: %.6f sekund" % (time.time() - start_time))
# czas wykonania funkcji bez dodatkowych bibliotek
start_time = time.time()
python_sum(a)
print("Czas wykonania funkcji bez NumPy: %.6f sekund" % (time.time() - start_time))

Przykład 2:

Pierwsza funkcja korzysta z numpy.dot(), a druga korzysta z pętli for.

import numpy as np
import time
# implementacja z użyciem NumPy
def numpy_dot(a, b):
return np.dot(a, b)
# implementacja bez dodatkowych bibliotek
def python_dot(a, b):
dot = 0
for i in range(len(a)):
dot += a[i] * b[i]
return dot
# tworzenie dwóch wektorów z losowymi liczbami
a = np.random.randint(0, 100, 700000)
b = np.random.randint(0, 100, 700000)
# czas wykonania funkcji z NumPy
start_time = time.time()
numpy_dot(a, b)
print("Czas wykonania funkcji z NumPy: %.6f sekund" % (time.time() - start_time))
# czas wykonania funkcji bez dodatkowych bibliotek
start_time = time.time()
python_dot(a, b)
print("Czas wykonania funkcji bez NumPy: %.6f sekund" % (time.time() - start_time))

Jak można zauważyć, funkcja z wykorzystaniem NumPy jest wyraźnie szybsza od implementacji z użyciem pętli for.

Biorąc pod uwagę, że zazwyczaj pracuje się na dużych zbiorach danych, ta różnica może być jeszcze większa.

Przeczytaj również: Wprowadzenie do świata Azure IoT

Zalety i wady korzystania z NumPy

Wykorzystanie NumPy w projekcie wiąże się z wieloma korzyściami i ułatwieniami, poniżej zebrałem najważniejsze z nich.

Zalety NumPy

• Szybkość – główną zaletą NumPy jest szybkość, ponieważ rozwiązania w tej bibliotece bazują na niskopoziomowym języku C. Obliczenia są zoptymalizowane i pozwalają na wykonywanie operacji w sposób wektorowy, co w znaczący sposób przekłada się na wzrost wydajności.
• Próg wejścia – NumPy ma niski próg wejścia dla osób, które na co dzień nie mają do czynienia z programowaniem. Umożliwia łatwe tworzenie lub modyfikację istniejących rozwiązań, które używane są w przetwarzaniu dużych zbiorów danych, w tym przypadku numerycznych.
• Zakres operacji – jak omówiono w przykładach, NumPy posiada szeroki zakres operacji numerycznych. Umożliwia wykonanie prostych działań arytmetyczno-logicznych, ale też zadań sortowania czy operacji statystycznych. Dodatkowo działa niezależnie od platformy czy systemu operacyjnego. Jeżeli możesz korzystać z Pythona, pewnie skorzystasz również z NumPy.
• Integracja z innymi bibliotekami – NumPy dobrze współpracuje z innymi bibliotekami, które używane są w analizie i pracy z dużymi zbiorami danych. Przykładem może być integracja z Pandas, Matplotlib lub SciPy.

Wady NumPy

Należy też pamiętać o potencjalnych utrudnieniach, które mogą wynikać z używania biblioteki NumPy nie do końca zgodnie z jej przeznaczeniem.

• Wykorzystanie pamięci – biblioteka ta wykorzystana w niewłaściwy sposób może używać sporo pamięci, a to z kolei – wpłynąć na wydajność w przetwarzaniu ogromnych zbiorów danych. Ważne jest właściwe zrozumienie składni i znajomość pojęć matematycznych, które stoją za funkcjami dostarczanymi przez bibliotekę.
• Ograniczone wykorzystanie – NumPy nie wspiera tablic o zmiennej długości, dlatego nie nadaje się do pracy na przykład z danymi tekstowymi. Istnieją inne biblioteki, które w tym przypadku poradzą sobie lepiej.
• Indeksowanie może być skomplikowane – to temat na odrębny artykuł, ale należy wspomnieć, że NumPy pozwala na zaawansowane indeksowanie tablic, które poprawia wydajność programu. Wymaga to jednak praktyki i bardzo dobrego zrozumienia zarówno samej biblioteki, jak i przetwarzanego zbioru danych.

Podsumowanie

Mam nadzieję, że udało mi się przedstawić podstawowe zagadnienia związane z przetwarzaniem danych numerycznych za pomocą biblioteki NumPy i pokazać jej potencjalne możliwości. Implementacja w realnych projektach pozwoli w pełni pokazać jej potencjał i korzyści wynikające z użycia funkcji, których dostarcza. Szybkość, integracja z innymi bibliotekami i łatwość użycia zdecydowanie zachęcają do zapoznania się z jej możliwościami. Oczywiście, jak w każdym przypadku, sprawne korzystanie z tej biblioteki przychodzi z czasem, ale już od pierwszych godzin może przynieść zadowalające efekty.

FAQ