Sök…
Introduktion
N-dimensionella matriser eller ndarrays är numpys kärnobjekt som används för att lagra objekt av samma datatyp. De ger en effektiv datastruktur som är överlägsen vanliga Pythons matriser.
Anmärkningar
Närhelst möjligt uttrycka operationer på data i terrays och vektoroperationer. Vektoroperationer utför mycket snabbare än motsvarande för slingor
Skapa en matris
Tom matris
np.empty((2,3))
Observera att i detta fall är värdena i den här arrayen inte inställda. Detta sätt att skapa en matris är därför endast användbart om matrisen fylls senare i koden.
Från en lista
np.array([0,1,2,3])
# Out: array([0, 1, 2, 3])
Skapa ett intervall
np.arange(4)
# Out: array([0, 1, 2, 3])
Skapa nollor
np.zeros((3,2))
# Out:
# array([[ 0., 0.],
# [ 0., 0.],
# [ 0., 0.]])
Skapa en
np.ones((3,2))
# Out:
# array([[ 1., 1.],
# [ 1., 1.],
# [ 1., 1.]])
Skapa linjära fördelade arrayobjekt
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. ])
Skapa log-distribuerade arrayobjekt
np.logspace(-2,2,5)
# Out:
# array([ 1.00000000e-02, 1.00000000e-01, 1.00000000e+00,
# 1.00000000e+01, 1.00000000e+02])
Skapa matris från en given funktion
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.]])
Arrayoperatörer
x = np.arange(4)
x
#Out:array([0, 1, 2, 3])
skalartillskott är elementmässigt
x+10
#Out: array([10, 11, 12, 13])
skalförökning är elementvis
x*2
#Out: array([0, 2, 4, 6])
array-tillägg är elementmässigt
x+x
#Out: array([0, 2, 4, 6])
matrismultiplikation är elementvis
x*x
#Out: array([0, 1, 4, 9])
punktprodukt (eller mer allmänt matrismultiplikation) görs med en funktion
x.dot(x)
#Out: 14
I Python 3.5 lades @ -operatören till som en infix-operatör för matrismultiplikation
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]])
'''
Bifoga . Returnerar kopia med bifogade värden. INTE på plats.
#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 . Horisontell stack. (kolonnstapel)
vstack . Vertikal stapel. (rad stack)
# 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]])
Array Access
Skivsyntax är i:j:k där i är startindex (inklusive), j är stoppindex (exklusivt) och k är stegstorlek. Liksom andra python-datastrukturer har det första elementet ett index på 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])
Negativa värden räknas in från slutet av matrisen. -1 därför åtkomst till det sista elementet i en matris:
x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])
Flerdimensionella matriser kan nås genom att specificera varje dimension separerad med komma-tecken. Alla tidigare regler gäller.
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]])
Transponera en matris
arr = np.arange(10).reshape(2, 5)
Med hjälp av .transpose metod:
arr.transpose()
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
.T metod:
arr.T
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Eller np.transpose :
np.transpose(arr)
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
I fallet med en tvådimensionell matris motsvarar detta en standardmatristransponering (såsom visas ovan). I det n-dimensionella fallet kan du ange en permutation av matrisaxlarna. Som standard vänder detta 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]]])
Men varje permutation av axelindex är möjlig:
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)
Booleska indexering
arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])
Jämförelse med en skalär returnerar en boolesisk matris:
arr > 4
# Out: array([False, False, False, False, False, True, True], dtype=bool)
Denna matris kan användas vid indexering för att bara välja siffror större än 4:
arr[arr>4]
# Out: array([5, 6])
Boolean indexering kan användas mellan olika matriser (t.ex. relaterade parallella arrayer):
# 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])
Omforma en matris
numpy.reshape (samma som numpy.ndarray.reshape ) returnerar en matris med samma totala storlek, men i en ny form:
print(np.arange(10).reshape((2, 5)))
# [[0 1 2 3 4]
# [5 6 7 8 9]]
Den returnerar en ny matris och fungerar inte på plats:
a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
Det är dock möjligt att skriva över shape attribut en ndarray :
a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Detta beteende kan vara överraskande till en början, men ndarray s lagras i sammanhängande minnesblock, och deras shape anger bara hur denna dataström ska tolkas som ett flerdimensionellt objekt.
Upp till en axel i shape tupel kan ha ett värde på -1 . numpy kommer då att sluta sig till längden på denna axel för dig:
a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Eller:
a = np.arange(12)
print(a.reshape((3, 2, -1)))
# [[[ 0 1]
# [ 2 3]]
# [[ 4 5]
# [ 6 7]]
# [[ 8 9]
# [10 11]]]
Flera ospecificerade dimensioner, t.ex. a.reshape((3, -1, -1)) är inte tillåtna och kommer att kasta en ValueError .
Broadcasting array operationer
Aritmetiska operationer utförs elementvis på Numpy-matriser. För matriser med identisk form betyder detta att operationen utförs mellan element på motsvarande index.
# 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])
Aritmetiska operationer kan också utföras på matriser av olika former med hjälp av Numpy- sändningar . I allmänhet "sänds" en grupp över den andra så att elementvisa operationer utförs på undergrupper med kongruent form.
# 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]])
För att illustrera detta ytterligare bör du överväga multiplikationen av 2D- och 3D-matriser med kongruenta underdimensioner.
# 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.
När används array-sändningar?
Sändning sker när två matriser har kompatibla former.
Former jämförs komponentmässigt med utgångspunkt från de efterföljande. Två dimensioner är kompatibla om de antingen är desamma eller om en av dem är 1 . Om en form har högre dimension än den andra, jämförs inte de överstående komponenterna.
Några exempel på kompatibla former:
(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)
Här är den officiella dokumentationen om array-sändningar .
Populera en matris med innehållet i en CSV-fil
filePath = "file.csv"
data = np.genfromtxt(filePath)
Många alternativ stöds, se officiell dokumentation för fullständig lista:
data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )
Numpy n-dimensionell matris: ndarray
Kärndatastrukturen i numpy är ndarray (kort för n- dimensionell matris). ndarray s är
- homogena (dvs. de innehåller artiklar av samma datatyp)
- innehåller objekt med fasta storlekar (ges av en form , en tupel av n positiva heltal som anger storleken för varje dimension)
Endimensionell matris:
x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)
Två-dimensionell matris:
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)
Tredimensionell:
np.arange(12).reshape([2,3,2])
För att initiera en matris utan att ange innehållet, använd:
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
Gissa datatyp och automatisk gjutning
Datatypen är inställd på att flyta som standard
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
x.dtype
# dtype('float64')
Om vissa data tillhandahålls, kommer numpy att gissa datatypen:
x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')
Observera att numpy när du gör uppdrag försöker automatiskt kasta värden som passar ndarray datatyp
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
Array-sändning
Se även sändningsmatrisoperationer .
x = np.asarray([[1, 2], [3, 4]])
# array([[1, 2],
[3, 4]])
y = np.asarray([[5, 6]])
# array([[5, 6]])
I matrixterminologi skulle vi ha en 2x2 matris och en 1x2 radvektor. Vi kan fortfarande göra en summa
# x + y
array([[ 6, 8],
[ 8, 10]])
Detta beror på att matrisen y är " sträckt " till:
array([[5, 6],
[5, 6]])
för att passa formen på x .
Resurser:
- Introduktion till ndarray från den officiella dokumentationen: N-dimensionell matris (ndarray)
- Klassreferens : ndarray .