NumPy Tutorial: Data Analysis with Python

Nie przegap naszego DARMOWEGO arkusza kalkulacyjnego NumPy na dole tego posta

NumPy jest powszechnie używanym pakietem do analizy danych w Pythonie. Używając NumPy, możesz przyspieszyć swój przepływ pracy i połączyć się z innymi pakietami w ekosystemie Pythona, takimi jak scikit-learn, które używają NumPy pod maską. NumPy został pierwotnie opracowany w połowie lat 2000, i powstał z jeszcze starszego pakietu o nazwie Numeric. Ta długowieczność oznacza, że prawie każdy pakiet do analizy danych lub uczenia maszynowego dla Pythona wykorzystuje NumPy w jakiś sposób.

W tym poradniku przejdziemy przez wykorzystanie NumPy do analizy danych dotyczących jakości wina. Dane zawierają informacje o różnych atrybutach win, takich jak pH i fixed acidity, wraz z wynikiem jakości pomiędzy 0 a 10 dla każdego wina. Wynik jakości jest średnią z co najmniej 3 ludzkich testerów smaku. W miarę jak będziemy się uczyć pracy z NumPy, spróbujemy dowiedzieć się więcej o postrzeganej jakości wina.

Wina, które będziemy analizować, pochodzą z regionu Minho w Portugalii.

Dane zostały pobrane z UCI Machine Learning Repository i są dostępne tutaj. Oto kilka pierwszych wierszy pliku winequality-red.csv, z którego będziemy korzystać w całym tym tutorialu:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Dane są w formacie, który będę nazywał ssv (semicolon separated values) – każdy rekord jest oddzielony średnikiem (;), a wiersze są oddzielone nowym wierszem. W pliku znajduje się 1600 wierszy, w tym wiersz nagłówkowy, oraz 12 kolumn.

Zanim zaczniemy, krótka uwaga dotycząca wersji – będziemy używać Pythona 3.5. Nasze przykłady kodu będą wykonane przy użyciu notatnika Jupyter.

Lists Of Lists for CSV Data

Przed użyciem NumPy, spróbujemy najpierw popracować z danymi używając Pythona i pakietu csv. Możemy wczytać plik za pomocą obiektu csv.reader, który pozwoli nam wczytać i podzielić całą zawartość z pliku ssv.

W poniższym kodzie:

• Importujemy bibliotekę csv.
• Otwieramy plik winequality-red.csv.
  • Przy otwartym pliku tworzymy nowy csv.readerobiekt.
    • Podaj argument słowa kluczowego delimiter=";", aby upewnić się, że rekordy są dzielone na znak średnika zamiast domyślnego znaku przecinka.
  • Wywołaj typ listy, aby pobrać wszystkie wiersze z pliku.
  • Przypisujemy wynik do wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Po wczytaniu danych możemy wypisać pierwsze 3 wiersze:

print(wines)

, , ]

Dane zostały wczytane do listy list. Każda wewnętrzna lista to wiersz z pliku ssv. Jak zapewne zauważyłeś, każdy element w całej liście list jest reprezentowany jako łańcuch znaków, co utrudni wykonywanie obliczeń.

Sformatujemy dane w tabelę, aby ułatwić ich przeglądanie:

Jak widać z powyższej tabeli, wczytaliśmy trzy wiersze, z których pierwszy zawiera nagłówki kolumn. Każdy wiersz po wierszu nagłówkowym reprezentuje wino. Pierwszy element każdego rzędu to fixed acidity, drugi to volatile acidity, i tak dalej. Możemy znaleźć średnią quality z win. Poniższy kod wykona:

• Wyodrębnienie ostatniego elementu z każdego wiersza po wierszu nagłówkowym.
• Konwersja każdego wyodrębnionego elementu na float.
• Przypisanie wszystkich wyodrębnionych elementów do listy qualities.
• Podziel sumę wszystkich elementów w qualities przez całkowitą liczbę elementów w qualities, aby uzyskać średnią.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Pomimo że udało nam się wykonać obliczenia, o które nam chodziło, kod jest dość skomplikowany i nie jest fajnie musieć robić coś podobnego za każdym razem, gdy chcemy obliczyć jakąś wielkość. Na szczęście możemy użyć NumPy, aby ułatwić sobie pracę z naszymi danymi.

Tablice dwuwymiarowe Numpy

Z NumPy pracujemy z tablicami wielowymiarowymi. Później zagłębimy się we wszystkie możliwe typy tablic wielowymiarowych, ale na razie skupimy się na tablicach dwuwymiarowych. Tablica dwuwymiarowa jest również znana jako macierz i jest czymś, co powinieneś znać. W rzeczywistości, jest to po prostu inny sposób myślenia o liście list. Macierz ma wiersze i kolumny. Poprzez określenie numeru wiersza i numeru kolumny, jesteśmy w stanie wyodrębnić element z macierzy.

W poniższej macierzy pierwszy wiersz to wiersz nagłówka, a pierwsza kolumna to kolumna fixed acidity:

Gdybyśmy wybrali element w pierwszym wierszu i drugiej kolumnie, otrzymalibyśmy volatile acidity. Gdybyśmy wybrali element w trzecim rzędzie i drugiej kolumnie, otrzymalibyśmy 0.88.

W tablicy NumPy liczba wymiarów nazywana jest rangą, a każdy wymiar nazywany jest osią. Tak więc wiersze są pierwszą osią, a kolumny są drugą osią.

Teraz, gdy rozumiesz podstawy macierzy, zobaczmy jak możemy dostać się z naszej listy list do tablicy NumPy.

Tworzenie tablicy NumPy

Możemy utworzyć tablicę NumPy używając funkcji numpy.array. Jeśli podamy listę list, to automatycznie zostanie utworzona tablica NumPy z taką samą liczbą wierszy i kolumn. Ponieważ chcemy, aby wszystkie elementy tablicy były elementami typu float dla ułatwienia obliczeń, pominiemy wiersz nagłówkowy, który zawiera łańcuchy znaków. Jednym z ograniczeń NumPy jest to, że wszystkie elementy w tablicy muszą być tego samego typu, więc jeśli uwzględnimy wiersz nagłówka, wszystkie elementy tablicy zostaną wczytane jako łańcuchy. Ponieważ chcemy mieć możliwość wykonywania obliczeń, takich jak znalezienie średniej quality win, potrzebujemy, aby wszystkie elementy były floatami.

W poniższym kodzie:

• Importujemy pakiet numpy.
• Przekazujemy listę list wines do funkcji array, która przekształca ją w tablicę NumPy.
  • Wykluczamy wiersz nagłówka za pomocą krojenia listy.
  • Specyfikujemy argument słowa kluczowego dtype, aby upewnić się, że każdy element zostanie przekonwertowany na float. Zanurzymy się bardziej w to, czym jest dtype później.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Spróbuj uruchomić powyższy kod i zobacz, co się stanie!

Jeśli wyświetlimy wines, otrzymamy teraz tablicę NumPy:

wines

array(,,,...,,,])

Możemy sprawdzić liczbę wierszy i kolumn w naszych danych używając właściwości shape tablic NumPy:

wines.shape

(1599, 12)

Alternatywne metody tworzenia tablic NumPy

Istnieje wiele metod, których możesz użyć do tworzenia tablic NumPy. Na początek można utworzyć tablicę, w której każdy element jest zerem. Poniższy kod utworzy tablicę z 3 wierszami i 4 kolumnami, gdzie każdy element jest 0, używając numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

Przydatne jest utworzenie tablicy z wszystkimi zerowymi elementami w przypadkach, gdy potrzebujesz tablicy o stałym rozmiarze, ale nie masz jeszcze żadnych wartości dla niej.

Możesz również utworzyć tablicę, gdzie każdy element jest liczbą losową używając numpy.random.rand. Oto przykład:

np.random.rand(3,4)

array(,,])

Tworzenie tablic pełnych liczb losowych może być przydatne, gdy chcesz szybko przetestować swój kod z przykładowymi tablicami.

Using NumPy To Read In Files

Możliwe jest użycie NumPy do bezpośredniego odczytu csv lub innych plików do tablic. Możemy to zrobić za pomocą funkcji numpy.genfromtxt. Możemy jej użyć do wczytania naszych wstępnych danych na temat czerwonych win.

W poniższym kodzie:

• Użyj funkcji genfromtxt do wczytania pliku winequality-red.csv.
• Zdefiniuj argument słowa kluczowego delimiter=";", aby pola były poprawnie parsowane.
• Sprecyzuj argument słowa kluczowego skip_header=1, aby wiersz nagłówka został pominięty.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wineskończy się tak samo, jakbyśmy przeczytali go do listy, a następnie przekonwertowali go na tablicę float. NumPy automatycznie wybierze typ danych dla elementów w tablicy na podstawie ich formatu.

Indeksowanie tablic NumPy

Wiemy już jak tworzyć tablice, ale dopóki nie możemy pobierać z nich wyników, nie ma zbyt wiele do zrobienia z NumPy. Możemy używać indeksowania tablicy do wybierania pojedynczych elementów, grup elementów lub całych wierszy i kolumn. Ważną rzeczą, o której należy pamiętać jest to, że tak jak listy Pythona, NumPy ma indeks zerowy, co oznacza, że indeks pierwszego wiersza to 0, a indeks pierwszej kolumny to 0. Jeśli chcemy pracować z czwartym rzędem, użylibyśmy indeksu 3, jeśli chcemy pracować z drugim rzędem, użylibyśmy indeksu 1, i tak dalej. Ponownie będziemy pracować z tablicą wines:

Wybierzmy element znajdujący się w wierszu 3 i kolumnie 4. W poniższym kodzie podajemy indeks 2 jako indeks wiersza oraz indeks 3 jako indeks kolumny. To pobiera wartość z czwartej kolumny trzeciego rzędu:

wines

2.2999999999999998

Ponieważ pracujemy z tablicą dwuwymiarową w NumPy, określamy 2 indeksy aby pobrać element. Pierwszy indeks jest indeksem wiersza lub osi 1, a drugi indeks jest indeksem kolumny lub osi 2, indeks. Każdy element w wines może być pobrany przy użyciu indeksów 2.

Slicing NumPy Arrays

Jeśli zamiast tego chcemy wybrać pierwsze trzy elementy z czwartej kolumny, możemy to zrobić używając dwukropka (:). Dwukropek wskazuje, że chcemy wybrać wszystkie elementy od indeksu początkowego do indeksu końcowego, ale nie włączając go. Jest to również znane jako wycinek:

wines

array()

Tak jak w przypadku wycinania listy, możliwe jest pominięcie 0, aby po prostu pobrać wszystkie elementy od początku do elementu 3:

wines

array()

Możemy wybrać całą kolumnę, określając, że chcemy wszystkie elementy, od pierwszego do ostatniego. Określamy to poprzez użycie dwukropka (:), bez indeksów początkowych i końcowych. Poniższy kod wybierze całą czwartą kolumnę:

wines

array()

Wybraliśmy całą kolumnę powyżej, ale możemy również wyodrębnić cały wiersz:

wines

array()

Jeśli weźmiemy nasze indeksowanie do ekstremum, możemy wybrać całą tablicę używając dwóch dwukropków, aby wybrać wszystkie wiersze i kolumny w wines. Jest to świetny trik imprezowy, ale nie ma zbyt wielu dobrych zastosowań:

wines

array(,,<br />,<br />...,,,<br />])

Przypisywanie wartości do tablic NumPy

Możemy również użyć indeksowania do przypisania wartości do określonych elementów w tablicach. Możemy to zrobić przez przypisanie bezpośrednio do indeksowanej wartości:

wines = 10

To samo możemy zrobić dla plasterków. Aby nadpisać całą kolumnę, możemy zrobić tak:

wines = 50

Powyższy kod nadpisuje wszystkie wartości w jedenastej kolumnie wartością 50.

1-Wymiarowe tablice NumPy

Do tej pory pracowaliśmy z tablicami dwuwymiarowymi, takimi jak wines. NumPy jest jednak pakietem do pracy z tablicami wielowymiarowymi. Jednym z najczęstszych typów tablic wielowymiarowych jest tablica jednowymiarowa, czyli wektor. Jak być może zauważyłeś powyżej, kiedy pokroiliśmy wines, odzyskaliśmy tablicę jednowymiarową. Tablica 1-wymiarowa potrzebuje tylko jednego indeksu, aby pobrać element. Każdy wiersz i kolumna w tablicy dwuwymiarowej jest tablicą jednowymiarową. Tak jak lista list jest analogiczna do tablicy 2-wymiarowej, pojedyncza lista jest analogiczna do tablicy 1-wymiarowej. Jeśli pokroimy win i pobierzemy tylko trzeci wiersz, otrzymamy tablicę jednowymiarową:

third_wine = wines

Tak wygląda third_wine:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Możemy pobierać poszczególne elementy z third_wine za pomocą pojedynczego indeksu. Poniższy kod wyświetli drugi element w third_wine:

third_wine

0.28000000000000003

Większość funkcji NumPy, z którymi pracowaliśmy, takich jak numpy.random.rand, może być używana z tablicami wielowymiarowymi. Oto jak użylibyśmy numpy.random.rand do wygenerowania wektora losowego:

np.random.rand(3)

array()

Poprzednio, kiedy wywołaliśmy np.random.rand, przekazaliśmy kształt dla tablicy dwuwymiarowej, więc wynikiem była tablica dwuwymiarowa. Tym razem przekazaliśmy kształt dla tablicy jednowymiarowej. Kształt określa ilość wymiarów oraz rozmiar tablicy w każdym wymiarze. Kształt (10,10) będzie tablicą dwuwymiarową o 10 wierszach i 10 kolumnach. Kształt (10,) będzie 1-wymiarową tablicą z 10 elementami.

Gdzie NumPy staje się bardziej skomplikowany jest wtedy, gdy zaczynamy zajmować się tablicami, które mają więcej niż 2 wymiarów.

N-wymiarowe tablice NumPy

Nie zdarza się to zbyt często, ale są przypadki, kiedy będziesz chciał poradzić sobie z tablicami, które mają więcej niż 3 wymiarów. Jednym ze sposobów, aby o tym pomyśleć jest lista list list list. Załóżmy, że chcemy przechowywać miesięczne zarobki sklepu, ale chcemy mieć możliwość szybkiego przeglądania wyników za kwartał i za rok. Zarobki za rok mogą wyglądać następująco:

Sklep zarobił 0 w styczniu, 5 w lutym, i tak dalej. Możemy podzielić te zarobki według kwartałów na listę list:

year_one = , , , ]

Możemy pobrać zarobki ze stycznia, wywołując year_one. Jeśli chcemy wyniki dla całego kwartału, możemy wywołać year_one lub year_one. Mamy teraz dwuwymiarową tablicę, czyli macierz. Ale co jeśli teraz chcemy dodać wyniki z innego roku? Musimy dodać trzeci wymiar:

earnings = , , , ], , , , ]]

Możemy pobrać zarobki ze stycznia pierwszego roku, wywołując earnings. Potrzebujemy teraz trzech indeksów, aby pobrać pojedynczy element. Tablica trójwymiarowa w NumPy jest bardzo podobna. W rzeczywistości możemy przekonwertować earnings na tablicę, a następnie uzyskać zarobki za styczeń pierwszego roku:

earnings = np.array(earnings)earnings

500

Możemy również znaleźć kształt tablicy:

earnings.shape

(2, 4, 3)

Indeksowanie i krojenie działają dokładnie w ten sam sposób z tablicą trójwymiarową, ale teraz mamy dodatkową oś do przekazania. Jeśli chcielibyśmy uzyskać zarobki za styczeń ze wszystkich lat, moglibyśmy zrobić tak:

earnings

array()

Jeśli chcielibyśmy uzyskać zarobki za pierwszy kwartał z obu lat, moglibyśmy zrobić tak:

earnings

array(,])

Dodawanie kolejnych wymiarów może znacznie ułatwić wyszukiwanie danych, jeśli są one zorganizowane w określony sposób. Gdy przechodzimy od tablic 3-wymiarowych do 4-wymiarowych i większych, te same właściwości mają zastosowanie i mogą być indeksowane i krojone w ten sam sposób.

Typy danych NumPy

Jak wspomnieliśmy wcześniej, każda tablica NumPy może przechowywać elementy jednego typu danych. Na przykład, wines zawiera tylko wartości typu float. NumPy przechowuje wartości używając swoich własnych typów danych, które różnią się od typów Pythona takich jak float i str. Dzieje się tak dlatego, że rdzeń NumPy jest napisany w języku programowania zwanym C, który przechowuje dane inaczej niż typy danych Pythona. Typy danych NumPy mapują się między Pythonem i C, pozwalając nam używać tablic NumPy bez żadnych problemów z konwersją.

Możesz znaleźć typ danych tablicy NumPy przez dostęp do właściwości dtype:

wines.dtype

dtype('float64')

NumPy ma kilka różnych typów danych, które w większości mapują się do typów danych Pythona, takich jak float i str. Możesz znaleźć pełną listę typów danych NumPy tutaj, ale oto kilka ważnych:

• float – numeryczne dane zmiennoprzecinkowe.
• int – dane całkowite.
• string – dane znakowe.
• object – obiekty Pythona.

Typy danych dodatkowo kończą się przyrostkiem, który wskazuje, ile bitów pamięci zajmują. Tak więc int32 jest 32-bitowym typem danych całkowitych, a float64 jest 64-bitowym typem danych float.

Konwersja typów danych

Możesz użyć metody numpy.ndarray.astype, aby przekonwertować tablicę na inny typ. Metoda ta faktycznie skopiuje tablicę i zwróci nową tablicę z określonym typem danych. Na przykład, możemy przekonwertować wines na typ danych int:

wines.astype(int)

array(,,,...,,,])

Jak widać powyżej, wszystkie elementy w wynikowej tablicy są liczbami całkowitymi. Zauważ, że użyliśmy typu danych Pythona int zamiast typu danych NumPy podczas konwersji wines. To dlatego, że kilka typów danych Pythona, w tym float, int i string, mogą być używane z NumPy, i są automatycznie konwertowane do typów danych NumPy.

Możemy sprawdzić właściwość name dtype wynikowej tablicy, aby zobaczyć, jaki typ danych NumPy mapuje wynikową tablicę do:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

Tablica została przekonwertowana na 64-bitowy typ danych całkowitych. Pozwala to na bardzo długie wartości całkowite, ale zajmuje więcej miejsca w pamięci niż przechowywanie wartości jako 32-bitowe liczby całkowite.

Jeśli chcesz mieć większą kontrolę nad tym, jak tablica jest przechowywana w pamięci, możesz bezpośrednio tworzyć obiekty typu NumPy dtype, takie jak numpy.int32:

np.int32

numpy.int32

Możesz użyć ich bezpośrednio do konwersji między typami:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

Operacje tablicowe NumPy

NumPy ułatwia wykonywanie operacji matematycznych na tablicach. Jest to jedna z podstawowych zalet NumPy i sprawia, że wykonywanie obliczeń jest dość łatwe.

Single Array Math

Jeśli wykonasz którąkolwiek z podstawowych operacji matematycznych (/, *, -, +, ^) z tablicą i wartością, zastosuje ona operację do każdego z elementów tablicy.

Powiedzmy, że chcemy dodać 10 punktów do każdego wyniku jakości, ponieważ jesteśmy pijani i czujemy się hojni. Oto jak byśmy to zrobili:

wines + 10

array()

Zauważ, że powyższa operacja nie zmieni tablicy wines – zwróci nową tablicę jednowymiarową, w której 10 zostało dodane do każdego elementu w kolumnie jakości win.

Jeśli zamiast tego zrobilibyśmy +=, zmodyfikowalibyśmy tablicę w miejscu:

wines += 10wines

array()

Wszystkie inne operacje działają w ten sam sposób. Na przykład, jeśli chcemy pomnożyć każdy z wyników jakości przez 2, możemy to zrobić w następujący sposób:

wines * 2

array()

Multiple Array Math

Możliwe jest również wykonywanie operacji matematycznych pomiędzy tablicami. Spowoduje to zastosowanie operacji do par elementów. Na przykład, jeśli dodamy kolumnę quality do siebie, oto co otrzymamy:

wines + wines

array()

Zauważ, że jest to równoważne wines * 2 – jest to spowodowane tym, że NumPy dodaje każdą parę elementów. Pierwszy element w pierwszej tablicy jest dodawany do pierwszego elementu w drugiej tablicy, drugi do drugiego, i tak dalej.

Możemy również użyć tego do mnożenia tablic. Załóżmy, że chcemy wybrać wino, które maksymalizuje zawartość alkoholu i jakość (chcemy się upić, ale mamy klasę). Pomnożylibyśmy alcohol przez quality i wybrali wino z najwyższym wynikiem:

wines * wines

array()

Wszystkie typowe operacje (/, *, -, +, ^) będą działać między tablicami.

Rozgłaszanie

Jeśli tablice, na których operujesz, nie mają dokładnie tego samego rozmiaru, nie jest możliwe wykonywanie operacji na elementach. W przypadkach takich jak ten, NumPy wykonuje rozgłaszanie, aby spróbować dopasować elementy. Zasadniczo rozgłaszanie obejmuje kilka kroków:

• Porównywany jest ostatni wymiar każdej tablicy.
  • Jeśli długości wymiarów są równe lub jeden z wymiarów ma długość 1, to kontynuujemy.
  • Jeśli długości wymiarów nie są równe, a żaden z wymiarów nie ma długości 1, to występuje błąd.
• Kontynuuj sprawdzanie wymiarów, aż najkrótsza tablica nie będzie miała wymiarów.

Na przykład następujące dwa kształty są zgodne:

A: (50,3)B (3,)

Wynika to z tego, że długość wymiaru spływowego tablicy A wynosi 3, a długość wymiaru spływowego tablicy B wynosi 3. Są one równe, więc ten wymiar jest w porządku. Tablica B jest wtedy bez elementów, więc jesteśmy w porządku, a tablice są zgodne dla operacji matematycznych.

Zgodne są również następujące dwie figury:

A: (1,2)B (50,2)

Ostatni wymiar się zgadza, a A ma długość 1 w pierwszym wymiarze.

Te dwie tablice nie pasują do siebie:

A: (50,50)B: (49,49)

Długości wymiarów nie są równe, a żadna z tablic nie ma długości wymiaru równej 1.

Szczegółowe wyjaśnienie nadawania znajduje się tutaj, ale przejdziemy przez kilka przykładów, aby zilustrować zasadę:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

Powyższy przykład nie zadziałał, ponieważ dwie tablice nie mają pasującego wymiaru końcowego. Oto przykład, w którym ostatni wymiar pasuje:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Jak widać, array_two został rozesłany do każdego wiersza array_one. Oto przykład z naszymi danymi wines:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Elementy rand_array są rozgłaszane w każdym wierszu wines, więc pierwsza kolumna wines ma dodaną pierwszą wartość w rand_array, i tak dalej.

Metody tablicowe NumPy

Oprócz typowych operacji matematycznych, NumPy posiada również kilka metod, których można użyć do bardziej złożonych obliczeń na tablicach. Przykładem tego jest metoda numpy.ndarray.sum. Znajduje ona sumę wszystkich elementów w tablicy domyślnie:

wines.sum()

9012.0

Suma wszystkich naszych ocen jakości wynosi 154.1788. Możemy przekazać argument słowa kluczowego axis do metody sum, aby znaleźć sumy na osi. Jeśli wywołamy metodę sum na macierzy wines i podamy axis=0, znajdziemy sumy nad pierwszą osią macierzy. To da nam sumę wszystkich wartości w każdej kolumnie. Może się to wydawać odwrotne, że sumy nad pierwszą osią dadzą nam sumę każdej kolumny, ale jednym ze sposobów myślenia o tym jest to, że określona oś jest tą „odchodzącą”. Jeśli więc podamy axis=0, chcemy, aby wiersze odeszły, a my chcemy znaleźć sumy dla każdej z pozostałych osi w każdym wierszu:

wines.sum(axis=0)

array()

Możemy sprawdzić, czy wykonaliśmy sumę poprawnie, sprawdzając kształt. Kształt powinien wynosić 12, co odpowiada liczbie kolumn:

wines.sum(axis=0).shape

(12,)

Jeśli podamy axis=1, znajdziemy sumy nad drugą osią tablicy. To da nam sumę każdego wiersza:

wines.sum(axis=1)

array()

Istnieje kilka innych metod, które zachowują się jak metoda sum, w tym:

• numpy.ndarray.mean – znajduje średnią tablicy.
• numpy.ndarray.std – znajduje odchylenie standardowe tablicy.
• numpy.ndarray.min – znajduje minimalną wartość w tablicy.
• numpy.ndarray.max – znajduje maksymalną wartość w tablicy.

Pełną listę metod tablicowych można znaleźć tutaj.

NumPy Array Comparisons

NumPy umożliwia sprawdzenie, czy wiersze pasują do pewnych wartości, używając matematycznych operacji porównania, takich jak <, >, >=, <= i ==. Na przykład, jeśli chcemy sprawdzić, które wina mają ocenę jakości wyższą niż 5, możemy zrobić tak:

wines > 5

array(, dtype=bool)

Otrzymamy tablicę Boolean, która mówi nam, które z win mają ocenę jakości wyższą niż 5. Możemy zrobić coś podobnego z innymi operatorami. Na przykład, możemy zobaczyć, czy jakieś wina mają ocenę jakości równą 10:

wines == 10

array(, dtype=bool)

Subsetting

Jedną z potężnych rzeczy, które możemy zrobić z tablicą Boolean i tablicą NumPy jest wybranie tylko niektórych wierszy lub kolumn w tablicy NumPy. Na przykład, poniższy kod wybierze tylko wiersze w wines, gdzie jakość jest powyżej 7:

high_quality = wines > 7wines

array(,,])

Wybieramy tylko wiersze, w których high_quality zawiera wartość True, oraz wszystkie kolumny. Takie podzbiory ułatwiają filtrowanie tablic pod kątem określonych kryteriów. Na przykład, możemy szukać win o dużej zawartości alkoholu i wysokiej jakości. Aby określić wiele warunków, musimy umieścić każdy warunek w nawiasie i oddzielić warunki za pomocą ampersanda (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Możemy połączyć podzestawianie i przypisywanie, aby nadpisać pewne wartości w tablicy:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Reshaping NumPy Arrays

Możemy zmienić kształt tablic, zachowując wszystkie ich elementy. Często może to ułatwić dostęp do elementów tablicy. Najprostszym przekształceniem jest odwrócenie osi, więc wiersze stają się kolumnami i na odwrót. Możemy to osiągnąć za pomocą funkcji numpy.transpose:

np.transpose(wines).shape

(12, 1599)

Możemy użyć funkcji numpy.ravel, aby przekształcić tablicę w reprezentację jednowymiarową. Zasadniczo spłaszczy ona tablicę do długiej sekwencji wartości:

wines.ravel()

array()

Tutaj znajduje się przykład, w którym możemy zobaczyć uporządkowanie numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

Wreszcie, możemy użyć funkcji numpy.reshape do zmiany kształtu tablicy do określonego przez nas kształtu. Poniższy kod zmieni drugi wiersz wines w dwuwymiarową tablicę z 2 wierszami i 6 kolumnami:

wines.reshape((2,6))

array(,])

Łączenie tablic NumPy

W NumPy, bardzo często łączy się wiele tablic w jedną zunifikowaną tablicę. Możemy użyć numpy.vstack do pionowego układania wielu tablic w stos. Pomyśl o tym, jak elementy drugiej tablicy są dodawane jako nowe wiersze do pierwszej tablicy. Możemy wczytać zbiór danych winequality-white.csv, który zawiera informacje o jakości białych win, a następnie połączyć go z naszym istniejącym zbiorem danych, wines, który zawiera informacje o winach czerwonych.

W poniższym kodzie, my:

• Wczytaj winequality-white.csv.
• Wyświetl kształt white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Jak widać, mamy atrybuty dla 4898 win. Teraz, gdy mamy dane o białych winach, możemy połączyć wszystkie dane o winach.

W poniższym kodzie:

• Użyj funkcji vstack, aby połączyć wines i white_wines.
• Wyświetl kształt wyniku.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Jak widać, wynik ma 6497 wierszy, co jest sumą liczby wierszy w wines i liczby wierszy w red_wines.

Jeśli chcemy połączyć tablice w poziomie, gdzie liczba wierszy pozostaje stała, ale kolumny są łączone, to możemy użyć funkcji numpy.hstack. Tablice, które łączymy, muszą mieć tę samą liczbę wierszy, aby to zadziałało.

Wreszcie możemy użyć numpy.concatenate jako wersji ogólnego przeznaczenia hstack i vstack. Jeśli chcemy konkatenować dwie tablice, przekazujemy je do concatenate, a następnie określamy axis argument słowa kluczowego, wzdłuż którego chcemy konkatenować. Konkatenacja wzdłuż pierwszej osi jest podobna do vstack, a konkatenacja wzdłuż drugiej osi jest podobna do hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Jeśli jesteś zainteresowany dowiedzeniem się więcej o NumPy, sprawdź nasz interaktywny kurs o NumPy i Pandas. Możesz zarejestrować się i wykonać pierwsze misje za darmo.

Możesz również przenieść swoje umiejętności NumPy na wyższy poziom dzięki naszemu darmowemu arkuszowi NumPy Cheat Sheet!

Dalsza lektura

Powinieneś teraz mieć dobre pojęcie o NumPy i jak zastosować go do zbioru danych.

Jeśli chcesz się zagłębić bardziej, oto kilka zasobów, które mogą być pomocne:

• NumPy Quickstart – ma dobre przykłady kodu i obejmuje większość podstawowych funkcji NumPy.
• Python NumPy Tutorial – świetny samouczek na temat NumPy i innych bibliotek Pythona.
• Visual NumPy Introduction – przewodnik, który wykorzystuje grę w życie do zilustrowania koncepcji NumPy.

W naszym następnym samouczku bardziej zagłębimy się w Pandas, bibliotekę, która bazuje na NumPy i sprawia, że analiza danych jest jeszcze łatwiejsza. Rozwiązuje ona dwa z największych bolączek, którymi są:

• Nie można mieszać wielu typów danych w tablicy.
• Musisz pamiętać, jaki typ danych zawiera każda kolumna.

.