Szukaj…
Wprowadzenie
Tablice N-wymiarowe lub ndarrays są podstawowym obiektem numpy używanym do przechowywania elementów tego samego typu danych. Zapewniają wydajną strukturę danych, która przewyższa zwykłe tablice Pythona.
Uwagi
O ile to możliwe, należy wyrazić operacje na danych w postaci tablic i operacji wektorowych. Operacje wektorowe wykonują się znacznie szybciej niż w przypadku pętli
Utwórz tablicę
Pusta tablica
np.empty((2,3))
Zauważ, że w tym przypadku wartości w tej tablicy nie są ustawione. Ten sposób tworzenia tablicy jest zatem użyteczny tylko wtedy, gdy tablica jest wypełniana później w kodzie.
Z listy
np.array([0,1,2,3])
# Out: array([0, 1, 2, 3])
Utwórz zakres
np.arange(4)
# Out: array([0, 1, 2, 3])
Utwórz Zera
np.zeros((3,2))
# Out:
# array([[ 0., 0.],
# [ 0., 0.],
# [ 0., 0.]])
Stwórz
np.ones((3,2))
# Out:
# array([[ 1., 1.],
# [ 1., 1.],
# [ 1., 1.]])
Utwórz elementy tablicy z odstępami liniowymi
np.linspace(0,1,21)
# Out:
# array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 ,
# 0.45, 0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85,
# 0.9 , 0.95, 1. ])
Utwórz elementy tablicy z odstępami w logach
np.logspace(-2,2,5)
# Out:
# array([ 1.00000000e-02, 1.00000000e-01, 1.00000000e+00,
# 1.00000000e+01, 1.00000000e+02])
Utwórz tablicę z danej funkcji
np.fromfunction(lambda i: i**2, (5,))
# Out:
# array([ 0., 1., 4., 9., 16.])
np.fromfunction(lambda i,j: i**2, (3,3))
# Out:
# array([[ 0., 0., 0.],
# [ 1., 1., 1.],
# [ 4., 4., 4.]])
Operatory macierzy
x = np.arange(4)
x
#Out:array([0, 1, 2, 3])
dodawanie skalarne jest mądre
x+10
#Out: array([10, 11, 12, 13])
mnożenie skalarne jest mądre
x*2
#Out: array([0, 2, 4, 6])
dodawanie tablic jest zależne od elementu
x+x
#Out: array([0, 2, 4, 6])
mnożenie tablic jest oparte na elementach
x*x
#Out: array([0, 1, 4, 9])
iloczyn iloczynu (lub bardziej ogólnie mnożenie macierzy) odbywa się za pomocą funkcji
x.dot(x)
#Out: 14
W Pythonie 3.5 operator @ został dodany jako operator infix do mnożenia macierzy
x = np.diag(np.arange(4))
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]])
'''
print(x@x)
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 9]])
'''
Dołącz Zwraca kopię z dołączonymi wartościami. Nie na miejscu.
#np.append(array, values_to_append, axis=None)
x = np.array([0,1,2,3,4])
np.append(x, [5,6,7,8,9])
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x
# Out: array([0, 1, 2, 3, 4])
y = np.append(x, [5,6,7,8,9])
y
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
hstack . Poziomy stos. (stos kolumn)
vstack . Pionowy stos. (stos rzędów)
# np.hstack(tup), np.vstack(tup)
x = np.array([0,0,0])
y = np.array([1,1,1])
z = np.array([2,2,2])
np.hstack(x,y,z)
# Out: array([0, 0, 0, 1, 1, 1, 2, 2, 2])
np.vstack(x,y,z)
# Out: array([[0, 0, 0],
# [1, 1, 1],
# [2, 2, 2]])
Dostęp do macierzy
Składnia plastra to i:j:k gdzie i jest indeksem początkowym (włącznie), j jest indeksem zatrzymania (wyłącznym), a k jest wielkością kroku. Podobnie jak inne struktury danych w Pythonie, pierwszy element ma indeks 0:
x = np.arange(10)
x[0]
# Out: 0
x[0:4]
# Out: array([0, 1, 2, 3])
x[0:4:2]
# Out:array([0, 2])
Wartości ujemne liczą się od końca tablicy. -1 uzyskuje zatem dostęp do ostatniego elementu w tablicy:
x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])
Dostęp do tablic wielowymiarowych można uzyskać, określając każdy wymiar oddzielony przecinkami. Obowiązują wszystkie poprzednie zasady.
x = np.arange(16).reshape((4,4))
x
# Out:
# array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
x[1,1]
# Out: 5
x[0:3,0]
# Out: array([0, 4, 8])
x[0:3, 0:3]
# Out:
# array([[ 0, 1, 2],
# [ 4, 5, 6],
# [ 8, 9, 10]])
x[0:3:2, 0:3:2]
# Out:
# array([[ 0, 2],
# [ 8, 10]])
Transponowanie tablicy
arr = np.arange(10).reshape(2, 5)
Za .transpose metody .transpose :
arr.transpose()
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Metoda .T :
arr.T
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Lub np.transpose :
np.transpose(arr)
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
W przypadku macierzy dwuwymiarowej odpowiada to standardowej transpozycji macierzy (jak pokazano powyżej). W przypadku n-wymiarowym możesz określić permutację osi macierzy. Domyślnie odwraca to array.shape :
a = np.arange(12).reshape((3,2,2))
a.transpose() # equivalent to a.transpose(2,1,0)
# Out:
# array([[[ 0, 4, 8],
# [ 2, 6, 10]],
#
# [[ 1, 5, 9],
# [ 3, 7, 11]]])
Ale możliwa jest dowolna permutacja wskaźników osi:
a.transpose(2,0,1)
# Out:
# array([[[ 0, 2],
# [ 4, 6],
# [ 8, 10]],
#
# [[ 1, 3],
# [ 5, 7],
# [ 9, 11]]])
a = np.arange(24).reshape((2,3,4)) # shape (2,3,4)
a.transpose(2,0,1).shape
# Out:
# (4, 2, 3)
Indeksowanie boolowskie
arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])
Porównanie ze skalarem zwraca tablicę boolowską:
arr > 4
# Out: array([False, False, False, False, False, True, True], dtype=bool)
Tej tablicy można użyć podczas indeksowania, aby wybrać tylko liczby większe niż 4:
arr[arr>4]
# Out: array([5, 6])
Indeksowanie logiczne można stosować między różnymi tablicami (np. Powiązane tablice równoległe):
# Two related arrays of same length, i.e. parallel arrays
idxs = np.arange(10)
sqrs = idxs**2
# Retrieve elements from one array using a condition on the other
my_sqrs = sqrs[idxs % 2 == 0]
print(my_sqrs)
# Out: array([0, 4, 16, 36, 64])
Przekształcanie tablicy
Metoda numpy.reshape (taka sama jak metoda numpy.ndarray.reshape ) zwraca tablicę o tym samym rozmiarze całkowitym, ale w nowym kształcie:
print(np.arange(10).reshape((2, 5)))
# [[0 1 2 3 4]
# [5 6 7 8 9]]
Zwraca nową tablicę i nie działa w miejscu:
a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
Możliwe jest jednak zastąpienie atrybutu shape ndarray :
a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
To zachowanie może początkowo być zaskakujące, ale ndarray są przechowywane w ciągłych blokach pamięci, a ich shape określa jedynie, w jaki sposób ten strumień danych powinien być interpretowany jako obiekt wielowymiarowy.
Maksymalnie jedna oś w krotce shape może mieć wartość -1 . numpy dla ciebie długość tej osi:
a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Lub:
a = np.arange(12)
print(a.reshape((3, 2, -1)))
# [[[ 0 1]
# [ 2 3]]
# [[ 4 5]
# [ 6 7]]
# [[ 8 9]
# [10 11]]]
Wiele nieokreślonych wymiarów, np. a.reshape((3, -1, -1)) jest niedozwolonych i spowoduje ValueError .
Operacje tablic rozgłoszeniowych
Operacje arytmetyczne wykonywane są elementarnie na tablicach Numpy. W przypadku tablic o identycznym kształcie oznacza to, że operacja jest wykonywana między elementami o odpowiednich indeksach.
# Create two arrays of the same size
a = np.arange(6).reshape(2, 3)
b = np.ones(6).reshape(2, 3)
a
# array([0, 1, 2],
# [3, 4, 5])
b
# array([1, 1, 1],
# [1, 1, 1])
# a + b: a and b are added elementwise
a + b
# array([1, 2, 3],
# [4, 5, 6])
Operacje arytmetyczne można również wykonywać na tablicach o różnych kształtach za pomocą nadawania Numpy. Zasadniczo jedna tablica jest „rozgłaszana” nad drugą, tak że elementarne operacje są wykonywane na pod-tablicach o odpowiednim kształcie.
# Create arrays of shapes (1, 5) and (13, 1) respectively
a = np.arange(5).reshape(1, 5)
a
# array([[0, 1, 2, 3, 4]])
b = np.arange(4).reshape(4, 1)
b
# array([0],
# [1],
# [2],
# [3])
# When multiplying a * b, slices with the same dimensions are multiplied
# elementwise. In the case of a * b, the one and only row of a is multiplied
# with each scalar down the one and only column of b.
a*b
# array([[ 0, 0, 0, 0, 0],
# [ 0, 1, 2, 3, 4],
# [ 0, 2, 4, 6, 8],
# [ 0, 3, 6, 9, 12]])
Aby to zilustrować dalej, rozważ pomnożenie tablic 2D i 3D z przystającymi pod-wymiarami.
# Create arrays of shapes (2, 2, 3) and (2, 3) respectively
a = np.arange(12).reshape(2, 2, 3)
a
# array([[[ 0 1 2]
# [ 3 4 5]]
#
# [[ 6 7 8]
# [ 9 10 11]]])
b = np.arange(6).reshape(2, 3)
# array([[0, 1, 2],
# [3, 4, 5]])
# Executing a*b broadcasts b to each (2, 3) slice of a,
# multiplying elementwise.
a*b
# array([[[ 0, 1, 4],
# [ 9, 16, 25]],
#
# [[ 0, 7, 16],
# [27, 40, 55]]])
# Executing b*a gives the same result, i.e. the smaller
# array is broadcast over the other.
Kiedy stosuje się rozgłaszanie tablicowe?
Nadawanie odbywa się, gdy dwie tablice mają kompatybilne kształty.
Kształty są porównywane komponentowo, zaczynając od tych końcowych. Dwa wymiary są kompatybilne, jeśli są takie same lub jeden z nich ma wartość 1 . Jeśli jeden kształt ma większy wymiar od drugiego, komponenty przekraczające nie są porównywane.
Niektóre przykłady kompatybilnych kształtów:
(7, 5, 3) # compatible because dimensions are the same
(7, 5, 3)
(7, 5, 3) # compatible because second dimension is 1
(7, 1, 3)
(7, 5, 3, 5) # compatible because exceeding dimensions are not compared
(3, 5)
(3, 4, 5) # incompatible
(5, 5)
(3, 4, 5) # compatible
(1, 5)
Oto oficjalna dokumentacja dotycząca nadawania w tablicy .
Wypełnij tablicę zawartością pliku CSV
filePath = "file.csv"
data = np.genfromtxt(filePath)
Obsługiwanych jest wiele opcji, pełna lista znajduje się w oficjalnej dokumentacji :
data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )
Numpy n-wymiarowa tablica: ndarray
Podstawową strukturą danych w numpy jest ndarray (skrót od n- wymiarowej tablicy). ndarray s are
- jednorodny (tzn. zawierają elementy tego samego typu danych)
- zawierają elementy o stałych rozmiarach (podane przez kształt , krotkę n dodatnich liczb całkowitych, które określają rozmiary każdego wymiaru)
Tablica jednowymiarowa:
x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)
Tablica dwuwymiarowa:
x = np.asarray([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
x
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
x.shape
# (3, 5)
Trójwymiarowy:
np.arange(12).reshape([2,3,2])
Aby zainicjować tablicę bez określania jej zawartości, użyj:
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
Zgadywanie typu danych i automatyczne odlewanie
Typ danych jest domyślnie ustawiony na zmiennoprzecinkowy
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
x.dtype
# dtype('float64')
Jeśli podane zostaną niektóre dane, numpy odgadnie typ danych:
x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')
Zauważ, że wykonując przypisania, numpy spróbuje automatycznie rzutować wartości, aby pasowały do typu danych ndarray
x[1, 1] = 1.5 # assign a float value
x[1, 1]
# 1
# value has been casted to int
x[1, 1] = 'z' # value cannot be casted, resulting in a ValueError
Transmisja macierzowa
Zobacz także Operacje tablic rozgłoszeniowych .
x = np.asarray([[1, 2], [3, 4]])
# array([[1, 2],
[3, 4]])
y = np.asarray([[5, 6]])
# array([[5, 6]])
W terminologii macierzy mielibyśmy macierz 2x2 i wektor wiersza 1x2. Nadal jesteśmy w stanie zrobić sumę
# x + y
array([[ 6, 8],
[ 8, 10]])
Wynika to z tego, że tablica y jest „ rozciągnięta ” w celu:
array([[5, 6],
[5, 6]])
dopasować do kształtu x .
Zasoby:
- Wprowadzenie do ndarray z oficjalnej dokumentacji: Tablica N-wymiarowa (ndarray)
- Odwołanie do klasy: ndarray .